How to work with IAsyncDisposable in .NET 6

Dispose and Finalize are two techniques for releasing sources held by .Internet and .Net Core apps executing in the context of the CLR. If your application has unmanaged assets, you must create the essential code to launch these resources explicitly.

Considering the fact that finalization is non-deterministic and finalizers are expensive in terms of resource usage, the Dispose method is most well-liked more than a finalizer. You can use the Dispose system on any sort that implements the IDisposable interface. Ultimately, with the arrival of asynchronous programming, .Net needed an asynchronous counterpart to IDisposable. Thus the IAsyncDisposable interface was launched.

This post discusses the IAsyncDisposable interface and how to perform with it in C#. To operate with the code examples provided in this post, you really should have Visual Studio 2022 installed in your program. If you do not now have a duplicate, you can obtain Visible Studio 2022 listed here.

Create a console application challenge in Visual Studio 2022

To start with off, let’s create a .Net Core console software job in Visible Studio. Assuming Visual Studio 2022 is mounted in your process, observe the techniques outlined underneath to make a new .Web Core console software undertaking.

1. Launch the Visual Studio IDE.
2. Click on on “Create a new project.”
3. In the “Create a new project” window, find “Console App” from the list of templates shown.
4. Click Subsequent.
5. In the “Configure your new project” window shown next, specify the title and area for the new task.
6. In the “Additional Information” window, pick .Web 6. as the runtime and click Upcoming
7. Click Create.

This will build a new .Internet Core console application venture. We’ll use this project to function with the IAsyncDisposable interface in the subsequent sections of this article.

From IDisposable to IAsyncDisposable

The IDisposable interface has been all over due to the fact the early days of the .Web Framework, from .Internet Framework 1. to be specific. You in all probability have employed this interface generally when coming up with your lessons in .Web and .Net Main. If your course implements the IDisposable interface, it is sensible that you should contact the Dispose system explicitly.

However, several new options have been included to .Web Framework around the years. Since multithreading was resource intensive, asynchronous programming was extra to the blend. Asynchronous programming can strengthen the performance and responsiveness of your software for the reason that the contacting thread can keep on to complete other functions even though the technique identified as asynchronously proceeds to execute.

Styles that apply the IDisposable interface totally free up means synchronously and as a result can block other threads running on the system. Moreover, if you are unsuccessful to dispose an asynchronous disposable source, it could direct to deadlocks as very well. The IAsyncDisposable interface addresses the will need for freeing up means asynchronously.

When should really you use IAsyncDisposable?

You should really use IAsyncDisposable only when you have a class that requirements to release methods asynchronously. In other words and phrases, you should really use IAsyncDisposable if your class (or any of its subclasses) allocates resources that also employ IAsyncDisposable. In which situation, you must make sure that the DisposeAsync process is declared as digital in the foundation class.

As an case in point, you should really consider benefit of IAsyncDisposable when you’re performing with asynchronous streams and circumstances of unmanaged sources that are source-intense and really should be cleaned up. You can leverage the DisposeAsync technique of this interface to launch this kind of assets.

Utilizing the IAsyncDisposable interface

The IAsyncDisposable interface defines the DisposeAsync process. Take note that the DisposeAsync approach returns a ValueTask which signifies an asynchronous dispose procedure. Notice that any non-sealed class, i.e., any course that can be extended, should have an extra strategy referred to as DisposeAsyncCore that also returns a ValueTask.

A usual DisposeAsync implementation need to glimpse like this:

community async ValueTask DisposeAsync()

    // Conduct async cleanup below
    await DisposeAsyncCore()
    // Dispose all unmanaged assets
    Dispose(phony)
    GC.SuppressFinalize(this)

So, you can create your asynchronous code as in the example given below, and the objects of the operation will be disposed asynchronously.

await working with (SqlConnection dbConnection = new SqlConnection(connectionString))

  // The connection occasion will be disposed asynchronously when the
  // method encounters the conclusion of the using block.

Notice the await key word made use of prior to the applying statement in the preceding code snippet. The await key phrase right here informs the working with block to simply call DisposeAsync and not Dispose when the manage reaches the conclude of the employing block.

When should you carry out both IAsyncDisposable and IDisposable?

Microsoft endorses that you put into practice both equally IAsyncDisposable and IDisposable interfaces in your code. You should not think about IAsyncDisposable as a substitution for the IDisposable interface. As a substitute, you need to consider IAsyncDisposable to be just an additional way of implementing the dispose sample.

If you don’t put into action the Dispose approach, any code that does not run in the async context will block on the DisposeAsync technique so that the DisposeAsync technique can be executed synchronously. On top of that, when you are using IoC (inversion of regulate) containers and if your container has been disposed synchronously, a runtime exception might be thrown since the DisposeAsync technique will hardly ever be termed.

As Microsoft states in the .Web documentation:

It is typical when utilizing the IAsyncDisposable interface that courses will also put into action the IDisposable interface. A fantastic implementation pattern of the IAsyncDisposable interface is to be ready for possibly synchronous or asynchronous dispose. All of the direction for utilizing the dispose sample also applies to the asynchronous implementation.

Employ synchronous and asynchronous dispose in .Internet

The following code listing demonstrates how you can put into action a synchronous and an asynchronous dispose sample in your code:

community course Example : IDisposable, IAsyncDisposable

    private FileStream fileStream =
    new FileStream("D:\test.txt", FileMode.Build)
    general public void Dispose()
    
        // Create code right here to dispose sources synchronously
        fileStream.Dispose()
    
    community async ValueTask DisposeAsync()
    
        // Generate code here to dispose sources asynchronously
        await fileStream.DisposeAsync()
    

The Process.IAsyncDisposable interface was introduced with C# 8.. Comparable to IDisposable, you should dispose IAsyncDisposable objects at the end of an HTTP ask for. You must connect with GC.SupressFinalize(this) in your Dispose or DisposeAsync technique so that the garbage collector does not require to contact the destructor later on.