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

Parameters

resource

Type: SystemFuncTaskTResource
A function which acquires the resource used during the execution of the task.

body

Type: SystemFuncTaskTResource, Task
The continuation function which provides the Task which acts as the body of the using block.

Type Parameters

TResource

The type of resource used within the task and disposed of afterwards.

Return Value

This code implements support for the following construct without requiring the use of /.

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

This method expands on the using statement provided by C# by implementing support for IAsyncDisposable as described in IAsyncDisposable, using statements, and async/await.

Notes to Callers
If the resource function throws an exception, or if it returns , or if the TaskTResult it returns does not complete successfully, the resource will not be acquired by this method. In either of these situations the caller is responsible for ensuring the resource function cleans up any resources it creates.

The following example asynchronously acquires a resource by calling the user method AcquireResourceAsync. The resource will be disposed after the body executes. No result is return from this operation, as the body of the task block represents an asynchronous operation that does not return a result.

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

For reference, the following example demonstrates a (nearly) equivalent implementation of this behavior using the / operators.

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

.NET for Windows Store apps

.NET Framework

Portable Class Library

Threading Library

Reference