Область действия переменных в делегате

Это должно быть так, чтобы позволить анонимным методам (и лямбда-выражениям) использовать локальные переменные и параметры, область действия которых находится в содержащем методе.

Обходной путь заключается в том, чтобы либо использовать разные имена для переменной, либо создать обычный метод.

«Закрытие», созданное анонимной функцией, несколько отличается от того, что создается в других динамических языках (в качестве примера я буду использовать Javascript).

function thing() {
    var o1 = {n:1}
    var o2 = {dummy:"Hello"}
    return function() { return o1.n++; }
}

var fn = thing();
alert(fn());
alert(fn());

Этот небольшой фрагмент javascript будет отображать 1, а затем 2. Анонимная функция может получить доступ к переменной o1, поскольку она существует в своей цепочке областей видимости. Однако анонимная функция имеет полностью независимую область видимости, в которой она может создать другую переменную o1 и, таким образом, скрыть любую другую переменную ниже по цепочке областей видимости. Также обратите внимание, что все переменные во всей цепочке остаются, поэтому o2 будет продолжать существовать, удерживая ссылку на объект, пока переменная fn содержит ссылку на функцию.

Теперь сравните с анонимными функциями С#:

class C1 { public int n {get; set;} }
class C2 { public string dummy { get; set; } }

Func<int> thing() {
   var o1 = new C1() {n=1};
   var o2 = new C2() {dummy="Hello"};
   return delegate { return o1.n++; };
}
...
Func<int> fn = thing();
Console.WriteLine(fn());
Console.WriteLine(fn());

В этом случае анонимная функция не создает действительно независимую область видимости больше, чем объявление переменной в любом другом блоке кода внутри функции { } (используется в foreach, if и т.

Следовательно, применяются те же правила: код вне блока не может получить доступ к переменным, объявленным внутри блока, но вы также не можете повторно использовать идентификатор.

Закрытие создается, когда анонимная функция передается за пределы функции, в которой она была создана. Отличие от примера Javascript состоит в том, что останутся только те переменные, которые фактически используются анонимной функцией, поэтому в этом случае объект, удерживаемый o2, будет быть доступным для GC, как только это завершится,

Вы также получите CS0136 из такого кода:

  int i = 0;
  if (i == 0) {
    int i = 1;
  }

Объем 2-го объявления «i» однозначен, такие языки, как C++, не имеют с ним никаких проблем. Но разработчики языка C# решили запретить это. Учитывая приведенный выше фрагмент, вы все еще думаете, что это была плохая идея? Добавьте кучу лишнего кода, и вы сможете какое-то время смотреть на этот код и не замечать ошибки.

Обходной путь тривиален и безболезнен, просто придумайте другое имя переменной.

Это потому, что делегат может ссылаться на переменные вне делегата:

int i = 1;
VoidFunction t = delegate { Console.WriteLine(i); };

Если я правильно помню, компилятор создает член класса внешних переменных, на которые ссылается анонимный метод, чтобы это работало.

Вот обходной путь:

class Program
    {
        void Main()
        {
            VoidFunction t = RealFunction;
            int i = 1;
        }
        delegate void VoidFunction();
        void RealFunction() { int i = 0; }
    } 

На самом деле ошибка не имеет ничего общего с анонимными делегатами или лямбда-выражениями. Если вы попытаетесь скомпилировать следующую программу...

using System;

class Program
{
    static void Main()
    {
        // Action t = delegate
        {
            int i = 0;
        };

        int i = 1;
    }
}

... вы получаете точно такую ​​же ошибку, независимо от того, комментируете ли вы строку или нет. В справке по ошибке показан очень похожий случай. Я думаю, что разумно запретить оба случая на том основании, что программисты могут перепутать две переменные.