Почему захват изменяемой структурной переменной внутри замыкания в операторе using изменяет ее локальное поведение?

Это известная ошибка; мы обнаружили это пару лет назад. Исправление могло бы привести к сбою, а проблема довольно неясна; это пункты против его исправления. Таким образом, это никогда не было настолько приоритетным, чтобы на самом деле это исправить.

Это было в моей очереди потенциальных тем для блога уже пару лет; возможно, мне стоит об этом написать.

И, между прочим, ваше предположение о механизме, объясняющем ошибку, совершенно верно; там хорошая психическая отладка.

Итак, да, известная ошибка, но несмотря ни на что, спасибо за отчет!

Это связано со способом создания и использования типов замыканий. Кажется, есть небольшая ошибка в том, как csc использует эти типы. Например, вот IL, сгенерированный gmcs Mono при вызове MoveNext ():

      IL_0051:  ldloc.3
      IL_0052:  ldflda valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<int32> Foo/'<Main>c__AnonStorey0'::enumerator
      IL_0057:  call instance bool valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<int32>::MoveNext()

Обратите внимание, что он загружает адрес поля, что позволяет вызову метода изменять экземпляр типа значения, хранящегося в объекте закрытия. Это то, что я считаю правильным поведением, и это приводит к точному перечислению содержимого списка.

Вот что генерирует csc:

      IL_0068:  ldloc.3
      IL_0069:  ldfld valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<int32> Tinker.Form1/'<>c__DisplayClass3'::enumerator
      IL_006e:  stloc.s 5
      IL_0070:  ldloca.s 5
      IL_0072:  call instance bool valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<int32>::MoveNext()

Итак, в этом случае он берет копию экземпляра типа значения и вызывает метод для этой копии. Неудивительно, почему это ни к чему не приведет. Вызов get_Current () также неверен:

      IL_0052:  ldloc.3
      IL_0053:  ldfld valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<int32> Tinker.Form1/'<>c__DisplayClass3'::enumerator
      IL_0058:  stloc.s 5
      IL_005a:  ldloca.s 5
      IL_005c:  call instance !0 valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<int32>::get_Current()
      IL_0061:  call void class [mscorlib]System.Console::WriteLine(int32)

Поскольку состояние копируемого перечислителя не вызвало MoveNext (), get_Current (), по-видимому, возвращает default(int).

Вкратце: csc кажется глючным. Интересно, что Mono получил это право, а MS.NET - нет!

_{... Я хотел бы услышать комментарии Джона Скита по поводу этой странности.}

В ходе обсуждения с brajkovic в #mono он определил, что спецификация языка C # на самом деле не детализирует, как должен быть реализован тип замыкания, а также то, как должны переводиться обращения локальных переменных, которые фиксируются в замыкании. Пример реализации в спецификации, кажется, использует метод «копирования», который использует csc. Следовательно, любой вывод компилятора можно считать правильным в соответствии со спецификацией языка, хотя я бы сказал, что csc должен по крайней мере скопировать локальный обратно в закрывающий объект после вызова метода.

ИЗМЕНИТЬ - Это неверно, я недостаточно внимательно прочитал вопрос.

Размещение структуры в замыкании вызывает присвоение. Присваивание типов значений приводит к созданию копии типа. Итак, что происходит: вы создаете новый Enumerator<int>, и Current в этом перечислителе вернет 0.

using System;
using System.Collections.Generic;

class Program
{
    static void Main(string[] args)
    {
        List<int> l = new List<int>();
        Console.WriteLine(l.GetEnumerator().Current);
    }
}

Результат: 0

Проблема в том, что перечислитель хранится в другом классе, поэтому каждое действие работает с копией перечислителя.

[CompilerGenerated]
private sealed class <>c__DisplayClass3
{
    // Fields
    public List<int>.Enumerator enumerator;

    // Methods
    public int <Main>b__1()
    {
        return this.enumerator.Current;
    }
}

public static void Main(string[] args)
{
    List<int> <>g__initLocal0 = new List<int>();
    <>g__initLocal0.Add(1);
    <>g__initLocal0.Add(2);
    <>g__initLocal0.Add(3);
    List<int> list = <>g__initLocal0;
    Func<int> CS$<>9__CachedAnonymousMethodDelegate2 = null;
    <>c__DisplayClass3 CS$<>8__locals4 = new <>c__DisplayClass3();
    CS$<>8__locals4.enumerator = list.GetEnumerator();
    try
    {
        if (CS$<>9__CachedAnonymousMethodDelegate2 == null)
        {
            CS$<>9__CachedAnonymousMethodDelegate2 = new Func<int>(CS$<>8__locals4.<Main>b__1);
        }
        while (CS$<>8__locals4.enumerator.MoveNext())
        {
            Console.WriteLine(CS$<>8__locals4.enumerator.Current);
        }
    }
    finally
    {
        CS$<>8__locals4.enumerator.Dispose();
    }
}

Без лямбда код будет ближе к тому, что вы ожидаете.

public static void Main(string[] args)
{
    List<int> <>g__initLocal0 = new List<int>();
    <>g__initLocal0.Add(1);
    <>g__initLocal0.Add(2);
    <>g__initLocal0.Add(3);
    List<int> list = <>g__initLocal0;
    using (List<int>.Enumerator enumerator = list.GetEnumerator())
    {
        while (enumerator.MoveNext())
        {
            Console.WriteLine(enumerator.Current);
        }
    }
}

Конкретный Иллинойс

L_0058: ldfld valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<int32> Machete.Runtime.Environment/<>c__DisplayClass3::enumerator
L_005d: stloc.s CS$0$0001
L_005f: ldloca.s CS$0$0001