Почему переменная scope класса захвачена при использовании метода async, но не при использовании Action <T> (примеры кода внутри)?

Ответ 1

У вас есть несколько неправильных представлений. Во-первых, когда вы вызываете DoIt, он возвращает задание, которое уже начало выполнение. Выполнение не запускается, только если вы await Задача.

Вы также создаете замыкание над переменной someString, значение которой не изменяется при переназначении поля уровня класса:

Task DoIt(string someString)
{
    return Task.Delay(0).ContinueWith(t 
        => Console.WriteLine("SomeString is '{0}'", someString));
}

Action, переданный в ContinueWith, закрывается в переменной someString. Помните, что строки неизменяемы, поэтому, когда вы переназначаете значение token, вы фактически назначаете новую ссылку на строку. Однако локальная переменная someString внутри DoIt сохраняет старую ссылку, поэтому ее значение остается неизменным даже после переназначения поля класса.

Вы можете решить эту проблему, вместо этого непосредственно связав это действие над полем класса:

Task DoIt()
{
    return Task.Delay(0).ContinueWith(t 
        => Console.WriteLine("SomeString is '{0}'", this.token));
}

Ответ 2

В обоих случаях вы делаете закрытие. Тем не менее, вы делаете замыкание на разные вещи в двух случаях.

В первом случае вы создаете анонимный метод с закрытием над this - когда вы, наконец, выполните делегат, он примет текущее значение this, получит текущее значение this.token и использовать это. Таким образом, вы видите измененное значение.

Во втором случае нет замыкания над this - или, если это так, это не имеет значения. Вы явно передаете this.token, а метод DoIt должен только закрывать свой собственный аргумент, someString. Это происходит немедленно (синхронно), а не лениво - поэтому фиксируется начальное значение this.token. await фактически не выполняет делегат - он только ждет результатов асинхронного метода. Сам метод уже запущен, и только его асинхронная часть, ну, асинхронная - в этом случае только Console.WriteLine("SomeString is '{0}'", someString).

Если вы хотите увидеть это более четко, добавьте Thread.Sleep(1000) после this.token = "Changed value"; - вы увидите распечатку SomeString is 'Initial Value', прежде чем вы даже дойдете до await.

Чтобы второй пример выглядел как первый, все, что вам нужно сделать, это изменить op как делегат снова, а не Task - var op = () => DoIt(this.token);. Это снова задерживает выполнение DoIt и вызывает то же закрытие, что и в первом примере.

TL; ДР:

Поведение отличается от того, что в первом случае вы откладываете выполнение DoIt(this.token), а во втором примере вы запускаете DoIt(this.token) немедленно. Остальные вопросы в моем ответе также важны, но в этом и заключается суть.

Ответ 3

Пусть разбивается каждый случай.

Начиная с Action<T>:

Мое объяснение: переменная не помещается в стек до тех пор, пока действие выполняется, поэтому оно будет изменено.

Это не имеет никакого отношения к стеку. Компилятор генерирует следующее из вашего первого фрагмента кода:

public foo()
{
    this.token = "Initial Value";
}

private void DoIt(string someString)
{
    Console.WriteLine("SomeString is '{0}'", someString);
}

public void Run()
{
    Action action = new Action(this.<Run>b__3_0);
    this.token = "Changed value";
    action();
}

[CompilerGenerated]
private void <Run>b__3_0()
{
    this.DoIt(this.token);
}

Компилятор испускает именованный метод из вашего выражения лямбда. Когда вы вызываете действие, и поскольку мы находимся в одном классе, this.token представляет собой обновленное "Измененное значение". Компилятор даже не поднимает это в класс отображения, так как это все создано и вызывается внутри метода экземпляра.

Теперь, для метода async. Создаются две государственные машины, они плохо разбираются в раздувании государственной машины и попадают в соответствующие части. Государство-машина выполняет следующее:

this.<>8__1 = new foo.<>c__DisplayClass4_0();
this.<>8__1.op = this.<>4__this.DoIt(this.<>4__this.token);
this.<>4__this.token = "Changed value";
taskAwaiter = this.<>4__this.Execute(new Func<Task>(this.<>8__1.<Run>b__0)).GetAwaiter();

Что здесь происходит? token передается на DoIt, который вернет a Func<Task>. Этот делегат содержит ссылку на старую строку токена "Начальное значение". Помните, хотя мы говорим о ссылочных типах, все они передаются по значению. Это фактически означает, что теперь есть новая ячейка хранения старой строки в методе DoIt, которая указывает на "Начальное значение". Затем следующая строка изменяет token на "Измененное значение". string, хранящийся внутри Func и тот, который был изменен, теперь указывает на две разные строки.

Когда вы вызываете делегата, он будет печатать начальное значение, так как задача op хранит ваше старое устаревшее значение. Вот почему вы видите два разных поведения.