Dispose and Finalize are two methods you often use to release resources occupied by your .NET and .NET Core applications running in the context of the CLR. Most importantly, if you have unmanaged resources in your application, you should release the resources occupied by such resources explicitly.
This article talks about the many ways you can dispose of objects that implement the IDisposable interface in ASP.NET Core 6.
To work with the code examples provided in this article, you should have Visual Studio 2022 installed in your system. If you don’t already have a copy, you can download Visual Studio 2022.
Create an ASP.NET Core Web API project in Visual Studio 2022
First, let’s create an ASP.NET Core project in Visual Studio 2022. Following these steps will create a new ASP.NET Core Web API 6 project in Visual Studio 2022:
- Launch the Visual Studio 2022 IDE.
- Click on “Create new project.”
- In the “Create new project” window, select “ASP.NET Core Web API” from the list of templates displayed.
- Click Next.
- In the “Configure your new project” window, specify the name and location for the new project.
- Optionally check the “Place solution and project in the same directory” check box, depending on your preferences.
- Click Next.
- In the “Additional Information” window shown next, select .NET 6.0 (Preview) as the target framework from the drop-down list at the top. Leave the “Authentication Type” as “None” (default). Ensure that the option “Use controllers …” is checked.
- Ensure that the checkboxes “Enable Docker,” “Configure for HTTPS,” and “Enable Open API Support” are unchecked as we won’t be using any of those features here.
- Click Create.
This will create a new ASP.NET Core 6 Web API project in Visual Studio 2022. We’ll use this project to work with objects that implement the IDisposable interface in the subsequent sections of this article.
Create a class that implements the IDisposable interface
We’ll now create a class that implements the IDisposable interface as shown in the code snippet given below.
The FileManager class implements the IDisposable interface and contains two methods – Write and Dispose. While the former is used to write text to a file asynchronously, the latter is used to remove the FileStream instance from memory by calling the Dispose method of the FileStream class.
Disposing IDisposable objects in ASP.NET Core 6
In this section, we’ll examine various ways in which we can dispose of IDisposable objects in ASP.NET Core 6.
Dispose IDisposable objects using the ‘using’ statement
The simplest way to dispose of an IDisposable instance is by using the “using” statement, which calls the Dispose method on the instance automatically. The following code snippet illustrates this.
Dispose IDisposable objects at the end of a request
When working in ASP.NET Core or ASP.NET Core MVC applications, you might often need to dispose of objects at the end of an HTTP request. The HttpResponse.RegisterForDispose method can be used to register IDisposable objects for disposal in this way. It accepts an instance of a class that implements the IDisposable interface and makes sure that the IDisposable object passed to it as a parameter is disposed automatically with each request.
The following code snippet illustrates how you can use the HttpResponse.RegisterForDispose method to register an instance of the FileManager class at the end of each HTTP request.
Dispose IDisposable objects using the built-in IoC container
Another approach to dispose IDisposable objects automatically is by using the built-in IoC (inversion of control) container in ASP.NET Core. You can take advantage of either Transient, Scoped, or Singleton instances to create services and add them to the built-in IoC container.
Add IDisposable objects to the IoC container in the ConfigureServices method of the Startup class so that those objects are disposed automatically with each HTTP request.
Dispose IDependency objects using IHostApplicationLifetime events
ASP.NET Core has an interface called IHostApplicationLifetime that allows you to run custom code when the application is started or shut down. You can take advantage of the Register method of this interface to register for events.
The Configure method of the Startup class can accept the following parameters:
The following code snippet shows how you can use the IHostApplicationLifetime interface to register objects for disposal when the application shuts down.
Finally, note that Startup.cs is not created by default in ASP.NET Core 6. You’ll need to create one manually and then write the following code in the Program.cs file to specify the Startup class you’ll be using in the application.
Unlike Finalize, we use the Dispose method explicitly to free unmanaged resources. You should call the Dispose method explicitly on any object that implements it to free any unmanaged resources for which the object may be holding references.
In this article, we’ve examined four ways of disposing such IDisposable objects. We can dispose of IDisposable objects by using the “using” statement, by disposing automatically at the end of each request, by using the IoC container, and by taking advantage of IHostApplicationLifetime events.