Using ConfigureAwait in "await using" declaration

[cincuranet]

Version Used:
3.0.100-preview3-010431

Steps to Reproduce:

When running the code below, the compiler says error CS1061: 'ConfiguredAsyncDisposable' does not contain a definition for 'Dummy' and no accessible extension method 'Dummy' accepting a first argument of type 'ConfiguredAsyncDisposable' could be found (are you missing a using directive or an assembly reference?) which makes absolute sense.

namespace test
{
	class AwaitUsingConfigureAwaitTest: IAsyncDisposable
	{
		public async ValueTask DisposeAsync()
		{
			await Task.CompletedTask;	
		}

		public async Task FooBar()
		{
			await using (var test = new AwaitUsingConfigureAwaitTest().ConfigureAwait(false))
			{
				test.Dummy();
			}
		}

		public void Dummy() { }
	}
}

That means the code has to be written like this.

public async Task FooBar()
{
	var test = new AwaitUsingConfigureAwaitTest();
	await using (test.ConfigureAwait(false))
	{
		test.Dummy();
	}
}

Not as succinct as before.

Is this the final state of this feature or is there some work still pending around this area?

[gafter]

/cc @chsienki @agocke @jcouv @MadsTorgersen

[jcouv]

Tagging @stephentoub as well

[agocke]

This is the final state of the feature for C# 8.

[DenSmoke]

var connection = new SqlConnection(Options.ConnectionString);
await using (connection.ConfigureAwait(false))
{
    var command = new SqlCommand(Query, connection) { CommandTimeout = Options.CommandTimeout };
    await using (command.ConfigureAwait(false))
    {
        await connection.OpenAsync().ConfigureAwait(false);
        var sqlDependency = new SqlDependency(command);
        sqlDependency.OnChange += SqlDependencyOnChange;
        CurrentSqlDependency = sqlDependency;
        await using var reader = (await command.ExecuteReaderAsync().ConfigureAwait(false)).ConfigureAwait(false);
    }
}

Instead of this:

await using var sc = new SqlConnection(Options.ConnectionString);
await using var command = new SqlCommand(Query, sc) { CommandTimeout = Options.CommandTimeout };
await sc.OpenAsync().ConfigureAwait(false);
var sqlDependency = new SqlDependency(command);
sqlDependency.OnChange += SqlDependencyOnChange;
CurrentSqlDependency = sqlDependency;
await using var reader = await command.ExecuteReaderAsync().ConfigureAwait(false);

I think it needs to be reviewed. I almost don't know situations when we need to continue on captured context. Even in UI I just use something like Dispatcher.Invoke or SynchronizationContext.Post and don't worry about context.

[qrli]

The ConfigureAwait(false) thing again and it is becoming more messy.
Instead of continuing this, I'd propose to have a standard way to leave the current synchronization context. It could be an API in corefx, not necessarily a language feature.

As some examples from discussions here before:

async Task Foo() {
  await AsyncHelper.LeaveSynchronizationContext();
  ... // effectively all awaits here behave like ConfigureAwait(false)'ed
}

Or

async Task Foo() {
  using (AsyncHelper.NoSynchronizationContext()) {
    ... // effectively all awaits here behave like ConfigureAwait(false)'ed
  }
}

Or with some compiler magic to make it nicer:

[ConfigureAwait(false)] // or maybe name it [NoSynchronizationContext]
async Task Foo() {
  ... // effectively all awaits here behave like ConfigureAwait(false)'ed
}

This can also relief the complains on ConfigureAwait(false).

[martingbrown]

I had the idea that we could have a modifier for the await keyword that would be both easy to type and do the .ConfigureAwait(false) thing. For example adding a ~ to it. So await~ SomeMethod(); would be expanded by the compiler to await SomeMethod().ConfigureAwait(false);. The same could be used in the await using case with await~ using.

[colejohnson66]

Please no keywords. They are cryptic and not expandable, especially now that other ConfigureAwait options are available.

[adams85]

You can also workaround this by abusing out parameter variable declarations:

public static class AsyncDisposableHelpers
{
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static IAsyncDisposable AsAsyncDisposable<T>(this T disposable, out T disposableOut) where T : notnull, IAsyncDisposable =>
        disposableOut = disposable;
}

then you can write

await using (new AwaitUsingConfigureAwaitTest().AsAsyncDisposable(out var test).ConfigureAwait(false))
{
    test.Dummy();
}

[krisztiankocsis]

Years after, I think the question is still valid and unanswered. Generaly no matter what you do, some of the Code Analysis warning, if they're enabled, are triggered. This problem should be officially solved by Microsoft.

[huoyaoyuan]

Talking about the analyzers, they does sometimes introduce false suggestions. They are considered less reliable.

But this feature is definitely a pain in the language.

[mysteryx93]

This hasn't been mentioned here; using Fody.ConfigureAwait is an easy solution to that mess.

It would be great to have a built-in solution though.

[owns]

ran into this issue today. Had to use 2 lines 😢.

var efContext = await _efContextFactory.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
await using var __ = efContext.ConfigureAwait(false);

Cannot use an out parameter with async. I feel like this is a false-positive. I don't think DisposeAsync should be ConfigureAwait since it should be fast enough 🤷‍♂️.

[mysteryx93]

If it's "fast enough" you don't need Async at all. That's designed for things that take an undetermined time. Let's say cleaning up temp files, shutting down a hard-drive, doing network stuff, or things like that. Perhaps an operation with 2 seconds timeout. Maybe disposing of a bunch of plugins, each doing their own things.

[rampaa]

Just came here to state my annoyance. Using await using together with ConfigureAwait shouldn't be this inconvenient.