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

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

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

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

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

public Task<string> UsingWithResult()
{
    return TaskBlocks.Using(
        () => AcquireResourceAsync(),
        task => task.Result.ReadToEndAsync());
}

private Task<StringReader> AcquireResourceAsync()
{
    // this would generally contain an asynchronous call
    return CompletedTask.FromResult(new StringReader("Text to read"));
}

public async Task<string> UsingWithResultAsyncAwait()
{
    using (StringReader resource = await AcquireResourceAsyncAwait())
    {
        return await resource.ReadToEndAsync();
    }
}

private async Task<StringReader> AcquireResourceAsyncAwait()
{
    // this would generally contain an asynchronous call
    return new StringReader("Text to read");
}