配置Await(false)和IAsyncDisposable的结构体实现

Question

我已经使用 ActionOnAsyncDispose 结构实现了 IAsyncDisposable，如下所示。我的理解是，当它处于 async using 语句中时，编译器不会将其装箱：

ActionOnDisposeAsync x = ...;
await using (x) {
     ...
}

正确吗？到目前为止，一切都很好。我的问题是，当我像这样配置等待时：

ActionOnDisposeAsync x = ...;
await using (x.ConfigureAwait()) {
     ...
}

x 会被装箱吗？如果我将ConfigureAwait 放入方法Caf() 中会怎么样：

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static public ConfiguredAsyncDisposable Caf(this ActionOnDisposeAsync disposable)
    => disposable.ConfigureAwait(false);

ActionOnDisposeAsync x = ...;
await using (x.Caf()) {
     ...
}

在这种情况下我可以避免装箱吗？我无法找到关于我的 using 变量到底需要实现什么才能实现ConfigureAwait 效果的文档。似乎也没有任何构建ConfiguredAsyncDisposable 的公共方法。

这是 ActionOnDisposeAsync：

public readonly struct ActionOnDisposeAsync : IAsyncDisposable, IEquatable<ActionOnDisposeAsync>
{
    public ActionOnDisposeAsync(Func<Task> actionAsync)
    {
        this.ActionAsync = actionAsync;
    }
    public ActionOnDisposeAsync( Action actionSync)
    {
        this.ActionAsync = () => { actionSync(); return Task.CompletedTask; };
    }
    private Func<Task> ActionAsync { get; }

    public async ValueTask DisposeAsync()
    {
        if (this.ActionAsync != null) {
            await this.ActionAsync();
        }
    }

    ...
}

Answer 1

是的，ConfigureAwait 在 struct 上一次性使用会导致装箱。以下是此行为的实验演示：

MyDisposableStruct value = new();
const int loops = 1000;
var mem0 = GC.GetTotalAllocatedBytes(true);
for (int i = 0; i < loops; i++)
{
    await using (value.ConfigureAwait(false)) { }
}
var mem1 = GC.GetTotalAllocatedBytes(true);
Console.WriteLine($"Allocated: {(mem1 - mem0) / loops:#,0} bytes per 'await using'");

...其中 MyDisposableStruct 是这个简单的结构：

readonly struct MyDisposableStruct : IAsyncDisposable
{
    public ValueTask DisposeAsync() => default;
}

输出：

Allocated: 24 bytes per 'await using'

现场演示。

为了防止装箱发生，您必须创建一个自定义 ConfiguredAsyncDisposable 类结构，专为您的结构定制。实现方法如下：

readonly struct MyConfiguredAsyncDisposable
{
    private readonly MyDisposableStruct _parent;
    private readonly bool _continueOnCapturedContext;

    public MyConfiguredAsyncDisposable(MyDisposableStruct parent,
        bool continueOnCapturedContext)
    {
        _parent = parent;
        _continueOnCapturedContext = continueOnCapturedContext;
    }

    public ConfiguredValueTaskAwaitable DisposeAsync()
        => _parent.DisposeAsync().ConfigureAwait(_continueOnCapturedContext);
}

static MyConfiguredAsyncDisposable ConfigureAwait(
    this MyDisposableStruct source, bool continueOnCapturedContext)
{
    return new MyConfiguredAsyncDisposable(source, continueOnCapturedContext);
}

现在运行与之前相同的实验，无需对代码进行任何更改，也不会导致分配。输出为：

Allocated: 0 bytes per 'await using'

现场演示。

Answer 2

如果编译器能够检测实际类型（您的结构），则不需要拳击。如果仅通过界面工作，则在处置时会进行。我的检查您的编译代码是否使用ILSPY之类的内容，您将查看是否在类（也是接口的情况）或值类型（/struct）上完成的Distose语句。

我不确定使用结构是否会在处置异步时会获得很多收益，并且是否值得付出努力，但是在决定之前，您应该衡量它。