晦涩编译器的 lambda 表达式翻译

Question

我研究了 Y Combinator（使用 c# 5.0），当这个方法时我感到很惊讶：

public static  Func<T1, Func<T2, TOut>> Curry<T1, T2, TOut> ( this Func<T1, T2, TOut> f)
{
    return a => b => f(a, b);
}

...被编译器翻译成这样：

public static Func<T1, Func<T2, TOut>> Curry<T1, T2, TOut>(this Func<T1, T2, TOut> f)
        {
            first<T1, T2, TOut> local = new first<T1, T2, TOut>();
            local.function = f;
            return new Func<T1, Func<T2, TOut>>(local.Curry);
        }
    private sealed class first<T1, T2, TOut>
    {
        private sealed class second
        {
            public first<T1, T2, TOut> ancestor;
            public T1 firstParameter;
            public TOut Curry(T2 secondParameter)
            {
                return ancestor.function(firstParameter, secondParameter);
            }
        }
        public Func<T1, T2, TOut> function;
        public Func<T2, TOut> Curry(T1 firstParameter)
        {
            second local = new second();
            local.ancestor = this;
            local.firstParameter = firstParameter;
            return new Func<T2, TOut>(local.Curry);
        }
    }

因此，当我们使用引用 second.Curry 的委托时，第二类是嵌套的，第一类不可用于垃圾收集。同时，我们在头等舱中所需要的只是功能。也许我们可以将它（委托）复制到第二类，然后可以收集第一类？是的，我们也应该做二等非嵌套，但似乎没关系。据我所知，代表是“按值”复制的，所以我可以建议它很慢，但同时我们复制 firstParameter？！那么，可能有人可以解释一下，为什么编译器会做所有这些事情？） 我谈论这样的事情：

private sealed class first<T1, T2, TOut>
{
        public Func<T1, T2, TOut> function;
        public Func<T2, TOut> Curry(T1 firstParameter)
        {
            second<T1, T2, TOut> local = new second<T1, T2, TOut>();
            local.function = function;
            local.firstParameter = firstParameter;
            return new Func<T2, TOut>(local.Curry);
        }
    }
    public sealed class second<T1, T2, TOut>
    {
        public T1 firstParameter;
        public Func<T1, T2, TOut> function;
        public TOut Curry(T2 secondParameter)
        {
            return function(firstParameter, secondParameter);
        }
    } 

Answer 1

这个问题很难理解。让我澄清一下。您的建议是编译器可以改为生成

public static Func<T1, Func<T2, TOut>> Curry<T1, T2, TOut>(this Func<T1, T2, TOut> f)
{
    first<T1, T2, TOut> local = new first<T1, T2, TOut>();
    local.function = f;
    return new Func<T1, Func<T2, TOut>>(local.Curry);
}
private sealed class first<T1, T2, TOut>
{
    private sealed class second
    {
        //public first<T1, T2, TOut> ancestor;
        public Func<T1, T2, TOut> function;
        public T1 firstParameter;
        public TOut Curry(T2 secondParameter)
        {
            return /*ancestor.*/function(firstParameter, secondParameter);
        }
    }
    // public Func<T1, T2, TOut> function;
    public Func<T2, TOut> Curry(T1 firstParameter)
    {
        second local = new second();
        // local.ancestor = this;
        local.function = function;
        local.firstParameter = firstParameter;
        return new Func<T2, TOut>(local.Curry);
    }
}

是吗？

您的说法是，由于这种情况，这是一种改进。

Func<int, int, int> adder = (x, y)=>x+y;
Func<int, Func<int, int>> makeAdder = adder.Curry();
Func<int, int> addFive = makeAdder(5);

• addFive 是 second 实例上的方法的委托
• makeAdder 是 first 实例上的方法的委托
• 在原始代码生成中，second 保留ancestor，这是first 的同一个实例

所以如果我们说

makeAdder = null;

那么first的实例无法被收集。该实例无法再通过makeAdder 访问，但可以通过addFive 访问。

在提议的代码生成中，first 可以在这种情况下收集，因为无法通过addFive 访问该实例。

您是正确的，在这种特定情况下优化是合法的。然而，由于 Ben Voigt 在他的回答中描述的原因，它一般是不合法的。 如果f 在Curry 中发生变异，那么local.function 必须发生变异。但是local 无法访问second 的实例直到执行外部委托强>.

C# 编译器团队可以选择执行您已确定的优化，但到目前为止，节省的小笔钱根本不值得费心。

我们正在考虑让 Roslyn 按照您描述的方式进行优化；也就是说，如果外部变量已知不会发生变异，则更积极地捕获其值。我不知道这种优化是否适用于 Roslyn。

Answer 2

您已经使用了两次 lambda 运算符，因此您将获得两个匿名委托，并将捕获的变量提升为状态类型。

内部 lambda 的状态类型通过引用保持外部 lambda 的状态类型的原因是，这就是 C# 中捕获的工作方式：您捕获的是一个变量，而不是它的值。

其他一些语言（例如 C++11 lambdas）具有替代语法来指示按值捕获与按引用捕获。 C# 没有，并且只是通过引用捕获所有内容。支持按值语义并不是一个很好的理由，因为垃圾回收避免了 C++11 中没有按值捕获模式时会存在的生命周期问题。

---

C# 编译器是否会注意到该变量从未被写入，因此按值捕获与按引用捕获没有区别？可能，但这是编译器中的额外逻辑，对设计和代码的额外审查，额外的测试。所有这些都是为了在内存占用和局部性方面进行微小的、几乎微不足道的改进。它显然不符合成本效益标准，您可以在 Eric Lippert 的许多博客文章中找到讨论。