public static Task Using<TResource>(
	Func<Task<TResource>> resource,
	Func<Task<TResource>, Task> body
)
where TResource : IDisposable

Public Shared Function Using(Of TResource As IDisposable) ( 
	resource As Func(Of Task(Of TResource)),
	body As Func(Of Task(Of TResource), Task)
) As Task

public:
generic<typename TResource>
where TResource : IDisposable
static Task^ Using(
	Func<Task<TResource>^>^ resource, 
	Func<Task<TResource>^, Task^>^ body
)

static member Using : 
        resource : Func<Task<'TResource>> * 
        body : Func<Task<'TResource>, Task> -> Task  when 'TResource : IDisposable

using (IDisposable disposable = await resource().ConfigureAwait(false))
{
    await body(disposable).ConfigureAwait(false);
}

public Task Using(StringBuilder builder)
{
    return TaskBlocks.Using(
        () => AcquireResourceAsync(builder),
        task => task.Result.WriteAsync(SampleText));
}

private Task<StringWriter> AcquireResourceAsync(StringBuilder builder)
{
    // this would generally contain an asynchronous call
    return CompletedTask.FromResult(new StringWriter(builder));
}

public async Task UsingAsyncAwait(StringBuilder builder)
{
    using (StringWriter resource = await AcquireResourceAsyncAwait(builder))
    {
        await resource.WriteAsync(SampleText);
    }
}

private async Task<StringWriter> AcquireResourceAsyncAwait(StringBuilder builder)
{
    // this would generally contain an asynchronous call
    return new StringWriter(builder);
}