c# - 何时首选lambda表达式中的参数？

这是一个很奇怪的问题，但是前几天又出现了，让我思考。

何时最好以这种形式使用Lambda表达式“。（（x => x.Whatever）”与“。（（）=> obj.Whatever）”。

考虑以下扩展方法。

public static class ExtensionMethods
{
    public static string TryToGetTheString<T>(this T value, Func<T, string> method)
    {
        try
        {
            return method(value);
        }
        catch (Exception)
        {
            return "banana";
        }
    }

    public static string TryToGetTheStringTwo<T>(this T value, Func<string> method)
    {
        try
        {
            return method();
        }
        catch (Exception)
        {
            return "banana";
        }
    }
 }

以及以下自引用类。

 public class testClass5000
 {
     private int? _id;
     public int? ID { get { return _id; } set { _id = value; } }

     private string _urgh;
     public string Urgh { get; set; }

     public testClass5000 tc5k { get; set; }
 }

然后，使用一个非常懒惰的过程来避免检查空值，同时尝试从testClass5000中获取字符串（Urgh），您可以实现扩展方法和此类的类，

    private void main()
    {
        var tc = new testClass5000();

        textBox1.text = tc.TryToGetTheString(x => x.tc5k.tc5k.tc5k.Urgh);

    }

但是，由于tc是在本地声明的，因此以下内容也适用。

    private void main()
    {
        var tc = new testClass5000();

        textBox1.text = tc.TryToGetTheStringTwo(() => tc.tc5k.tc5k.tc5k.Urgh);

    }

我很好奇何时需要(x => x.tc5k.tc5k.tc5k.Urgh)和何时首选(() => tc.tc5k.tc5k.tc5k.Urgh)。

/////////////////////////////////////////////

我确实提出了以下情况，其中传递参数似乎是可取的。

具有以下扩展方法。

public static class ExtensionMethods
{
    public static T TestOne<T>(this T value, Func<T, T> method)
    {
        try
        {
            return method(value);
        }
        catch (Exception)
        {
            return default(T);
        }
    }

    public static T TestTwo<T>(this T value, Func<T> method)
    {
        try
        {
            return method();
        }
        catch (Exception)
        {
            return default(T);
        }
    }
}

并使用以下代码。

    private void Form1_Load(object sender, EventArgs e)
    {
        var firstValue = 5;
        var secondValue = 10;

        var resultOne = firstValue.TestOne(x => x + 1).TestOne(x => x * 2);
        //returns 12
        var resultTwo = secondValue.TestTwo(() => secondValue + 1).TestTwo(() => secondValue * 2);
        //returns 20
        var resultThree = secondValue.TestTwo(() => secondValue.TestTwo(() => secondValue + 1) * 2);
        //returns 22
    }

在此示例中，.TestOne（x => x + 1）.TestOne（x => x + 2）是更可取的表示法，因为要实现相同的目的而不通过参数，则需要开始嵌套表达式。

最佳答案

如果参数与您提供的原始值根本不同。

一个简单的例子

public static class Extensions
{
    public static void DoSomething(this string s,Action<string> action)
    {
        var something = Enumerable.Range(1,100).Select(i=> String.Format("{0}_{1}",s,i));
        foreach (var ss in something)
        {
            action(ss);
        }
    }
}

然后

var something = "ABC123";

something.DoSomething(x=>Console.WriteLine(x));
//Ignoring that we could do something.DoSomething(Console.WriteLine);

显然，如果没有该参数，您将无法访问被插入的实际值，并且原始值在此概念内没有任何用处。

关于c# - 何时首选lambda表达式中的参数？，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/8356730/