Можно ли в функции возврата yield гарантировать, что финализатор вызывается в том же потоке?

Кажется, здесь идет гонка.

Похоже, ваш вызывающий код создает перечислитель, затем запускает задачу в пуле потоков для его перечисления, а затем удаляет перечислитель. Мои первоначальные мысли:

• Если перечислитель удаляется до начала перечисления, ничего не произойдет. Из краткого теста это не мешает перечислению после его удаления.

• Если перечислитель удаляется во время перечисления, будет вызван блок finally (в вызывающем потоке), и перечисление остановится.

• Если перечисление завершено действием задачи, будет вызван блок finally (в потоке пула потоков).

Чтобы попытаться продемонстрировать, рассмотрим этот метод:

private static IEnumerable<int> Items()
{            
    try
    {
        Console.WriteLine("Before 0");

        yield return 0;

        Console.WriteLine("Before 1");

        yield return 1;

        Console.WriteLine("After 1");
    }
    finally 
    {
        Console.WriteLine("Finally");
    }
}

Если вы распоряжаетесь перед перечислением, в консоль ничего не будет записано. Это то, что я подозреваю, что вы будете делать большую часть времени, так как текущий поток достигает конца блока using до начала задачи:

var enumerator = Items().GetEnumerator();
enumerator.Dispose();    

Если перечисление завершится до Dispose, последний вызов MoveNext вызовет блок finally.

var enumerator = Items().GetEnumerator();
enumerator.MoveNext();
enumerator.MoveNext();
enumerator.MoveNext();

Результат:

"Before 0"
"Before 1"
"After 1"
"Finally"

Если вы распоряжаетесь во время перечисления, вызов Dispose вызовет блок finally:

var enumerator = Items().GetEnumerator();
enumerator.MoveNext();
enumerator.Dispose();

Результат:

"Before 0"
"Finally"

Я предлагаю вам создать, перечислить и удалить перечислитель в одном потоке.

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

        BlockingCollection<Tuple<Guid, int>> c = new BlockingCollection<Tuple<Guid,int>>();

        Task.Factory.StartNew(() => {
            using (IEnumerator<Tuple<Guid, int>> iter = global.NarrowItemResultRepository.Narrow_GetCount_Batch(userData.NarrowItems, dicId2Nar.Values).GetEnumerator()) {

                while (iter.MoveNext()) {
                    c.Add(iter.Current);
                }
                c.CompleteAdding();
            }
        });

Термин «финализатор» относится к понятию, совершенно не связанному с «блоком «наконец»»; ничто в контексте многопоточности финализаторов не гарантируется, но я думаю, что вас действительно интересуют блоки «наконец».

Блок finally, окруженный блоком yield return, будет выполняться любым потоком, вызывающим Dispose в перечислителе итератора. Перечислители, как правило, имеют право предполагать, что все операции, выполняемые над ними, включая Dispose, будут выполняться тем же потоком, который их создал, и, как правило, не обязаны вести себя каким-либо образом, хотя бы отдаленно напоминающим разумный, в тех случаях, когда это не так. Система не запрещает коду использовать перечислители в нескольких потоках, но в случае, если программа использует перечислитель из нескольких потоков, который не обещает, что он будет работать в этом отношении, это означает, что любые вытекающие из этого последствия не являются ошибкой перечислителя. , а скорее по вине программы, которая использовала его нелегитимно.

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