using System;

using System.Runtime.CompilerServices;

using System.Threading.Tasks;

​

public static class Program

{

    public static async Task Main()

    {

        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'");

    }

​

    readonly struct MyDisposableStruct : IAsyncDisposable

    {

        public ValueTask DisposeAsync() => default;

    }

​

    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);

    }

}