Closure捕获变量也会修改原始变量

Question

我有以下简单的代码:

static void Main(string[] args)
{
    int j = 0;
    Func<int> f = () =>
    {
        for (int i = 0; i < 3; i++)
        {
            j += i;
        }
        return j;
    };

    int myStr = f();
    Console.WriteLine(myStr);
    Console.WriteLine(j);
    Console.Read();
}

根据我在涉及闭包时所读到的内容,编译器会创建一个新类型,以便它可以存储捕获的变量并维护对它的引用.但是,当我运行以下代码时,两个打印行显示3.我期待0和3,因为匿名方法在生成的类中由编译器具有自己的变量.那么它为什么还要修改外部变量呢？

Answer 1

外部变量和闭包中的变量是相同的变量.您的计划相当于:

private class Closure
{
    public int j;
    public int Method()
    {
        for (int i = 0; i < 3; i++)
        {
            this.j += i;
        }
        return this.j;
    }
}
static void Main(string[] args)
{
    Closure closure = new Closure();
    closure.j = 0;
    Func<int> f = closure.Method;
    int myStr = f();
    Console.WriteLine(myStr);
    Console.WriteLine(closure.j);
    Console.Read();
}

现在很明显为什么你得到观察到的结果？

Answer 2

这就是闭包的工作原理，它们捕获变量，而不是值。所以j会改。

如果你不想这样，你可以这样做：

static void Main(string[] args)
{
    int j = 0;
    Func<int> f = () =>
    {
        int k = j;
        for (int i = 0; i < 3; i++)
        {
            k += i;
        }
        return k;
    };
    int myStr = f();
    Console.WriteLine(myStr);
    Console.WriteLine(j);
    Console.Read();
}

j仍然被闭包捕获，但没有被修改。仅k修改副本。

编辑：

您正确地注意到这不适用于引用类型。在这种情况下，k = j存储对象引用的副本。仍然存在被引用对象的一个​​副本，因此对该对象的任何修改都会影响这两个变量。

下面是一个示例，说明如何将闭包用于引用类型而不更新原始变量：

static void Main(string[] args)
{
    Foo j = new Foo(0);
    Func<Foo> f = () =>
    {
        Foo k = new Foo(j.N); // Can't just say k = j;
        for (int i = 0; i < 3; i++)
        {
            k.N += 1;
        }
        return k;
    };

    Console.WriteLine(f().N);
    Console.WriteLine(j.N);
    Console.Read();
}

public class Foo
{
    public int N { get; set; }

    public Foo(int n) { N = n; }
}

但是，字符串是不可变的引用类型，您实际上可以说k = j，这与任意引用类型不同。考虑不变性的一种方式是，每次更新字符串的值时，实际上是在创建一个新实例。所以k = k + "1"就像说k = new String(k + "1")。那时，它不再是对与j.