2

我在枚举IAsyncEnumerable, 并附加了System.Linq.Async运算符时遇到了一个奇怪的问题。Take在我的迭代器中，我有一个 try-finally 块，块内产生了一些值，try块内有一些清理代码finally。清理代码位于lock块内。问题是块后面的任何代码lock都不会执行。没有抛出异常，只是忽略了代码，就像它不存在一样。这是一个重现此行为的程序：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

public class Program
{
    static async Task Main()
    {
        await foreach (var item in GetStream().Take(1))
        {
            Console.WriteLine($"Received: {item}");
        }
        Console.WriteLine($"Done");
    }

    static async IAsyncEnumerable<int> GetStream()
    {
        var locker = new object();
        await Task.Delay(100);
        try
        {
            yield return 1;
            yield return 2;
        }
        finally
        {
            Console.WriteLine($"Finally before lock");
            lock (locker) { /* Clean up */ }
            Console.WriteLine($"Finally after lock");
        }
    }
}

输出：

Received: 1
Finally before lock
Done

控制台中未打印文本“Finally after lock” ！

这只发生在Take连接了操作员的情况下。如果没有操作符，文本将按预期打印。

这是System.Linq.Async库中的错误、C# 编译器中的错误还是其他什么？

作为一种解决方法，我目前在 内部使用嵌套的 try-finally 块finally，它可以工作但很尴尬：

finally
{
    try
    {
        lock (locker) { /* Clean up */ }
    }
    finally
    {
        Console.WriteLine($"Finally after lock");
    }
}

.NET Core 3.1.3、.NET Framework 4.8.4150.0、C# 8、System.Linq.Async 4.1.1、Visual Studio 16.5.4、控制台应用程序

4

1 回答 1

3

不会声称我完全理解这个问题以及如何解决它（以及是谁的错），但这就是我发现的：

首先，finally 块被转换为下一个 IL：

  IL_017c: ldarg.0      // this
  IL_017d: ldfld        bool TestAsyncEnum.Program/'<GetStream>d__1'::'<>w__disposeMode'
  IL_0182: brfalse.s    IL_0186
  IL_0184: br.s         IL_0199
  IL_0186: ldarg.0      // this
  IL_0187: ldnull
  IL_0188: stfld        object TestAsyncEnum.Program/'<GetStream>d__1'::'<>s__2'

  // [37 17 - 37 58]
  IL_018d: ldstr        "Finally after lock"
  IL_0192: call         void [System.Console]System.Console::WriteLine(string)
  IL_0197: nop

  // [38 13 - 38 14]
  IL_0198: nop

  IL_0199: endfinally
} // end of finally

如您所见，编译器生成的代码具有下一个分支，仅当生成的枚举器不在 disposeMode 中时才会在语句IL_017d: ldfld bool TestAsyncEnum.Program/'<GetStream>d__1'::'<>w__disposeMode'之后运行代码。lock

System.Linq.Async有两个在内部使用AsyncEnumerablePartition-Skip和Take.的运算符 不同之处在于，当Take完成时它不会运行底层枚举器完成，并且Skip确实（我在这里详细说明了一点，原因还没有查看底层实现），所以当针对Takecase触发处理代码时，disposeMode设置为 true 和那部分代码没有运行。

这是重现问题的课程（基于nuget中发生的事情）：

public class MyAsyncIterator<T> : IAsyncEnumerable<T>, IAsyncEnumerator<T>
{
    private readonly IAsyncEnumerable<T> _source;
    private IAsyncEnumerator<T>? _enumerator;
     T _current = default!;
    public T Current => _current;

    public MyAsyncIterator(IAsyncEnumerable<T> source)
    {
        _source = source;
    }

    public IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = new CancellationToken()) => this;

    public async ValueTask DisposeAsync()
    {
        if (_enumerator != null)
        {
            await _enumerator.DisposeAsync().ConfigureAwait(false);
            _enumerator = null;
        }
    }

    private int _taken;
    public async ValueTask<bool> MoveNextAsync()
    {
        _enumerator ??= _source.GetAsyncEnumerator();

        if (_taken < 1 && await _enumerator!.MoveNextAsync().ConfigureAwait(false))
        {
            _taken++; // COMMENTING IT OUT MAKES IT WORK
            _current = _enumerator.Current;
            return true;
        }

        return false;
    }
}

并在您的代码中使用await foreach (var item in new MyAsyncIterator<int>(GetStream()))

我想说这是一些极端情况下的编译器问题，因为它似乎在 finally 块之后奇怪地处理所有代码，例如，如果在迭代器没有“完成”的情况下，你添加Console.WriteLine("After global finally");到它的末尾GetStream也不会被打印。您的解决方法有效，因为WriteLineis in finally 块。

在github上提交 issue ，看看 dotnet 团队会怎么说。

于 2020-05-03T21:47:47.407 回答