Закрытие захвачена переменная изменяет оригинал, а

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.

Edit:

Вы правильно отметить, что это не будет работать для ссылочных типов. В этом случае 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.

Answer 3

Спецификация языка говорит:

Анонимные методы подобны лямбда-функциям в языке программирования Lisp. C# 2.0 поддерживает создание «закрытий», когда анонимные методы получают доступ к локальным переменным и параметрам.

И «j» в вашем случае - окружающая переменная.