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

Question

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

什么时候使用“.(x => x.Whatever)”和“.(() => obj.Whatever)”形式的 lambda 表达式更可取。

考虑以下扩展方法。

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) 是更可取的表示法，因为要在不传递参数的情况下实现相同的目的，您需要开始嵌套表达式。

Answer 1

直接在 lambda 中注入(inject)参数值的成本更高，因为编译器必须为此目的创建一个特殊的类。

如果我们排除性能方面的考虑，那么我会说注入(inject)参数更容易编写(这里是个人偏好)，而将参数保留在原型(prototype)中( (x,y) =>//do something)在以下情况下很有用您实际上并不是提供参数值的人。例如，在使用 Select Linq 查询时。或者我经常将它用于负载平衡场景(lambda“service => service.SomeFunction()”，然后一个特殊的工厂检索服务并执行 lambda)。