How to use the Dispose method in C#

Key takeaways:
The garbage collector manages only managed resources; unmanaged resources need explicit cleanup.
Dispose ensures prompt release of unmanaged resources to prevent memory leaks.
It is a part of the IDisposable interface and Dispose provides deterministic resource cleanup.
It allows precise control over resource deallocation timing for efficient management.
It releases managed and unmanaged resources, with a finalizer as a fallback for unmanaged cleanup.
The Dispose(bool disposing) method differentiates explicit disposal from garbage collection.
The using statement auto-calls Dispose when an object goes out of scope.
Manual Dispose calls can use try-finally for guaranteed cleanup.
Proper use of Dispose boosts performance and avoids resource exhaustion.
Neglecting Dispose can lead to resource leaks and instability.

While the .NET runtime features automatic garbage collection to handle memory management, there are scenarios where implementing a custom Dispose method is essential for efficient resource management.

What is the `Dispose` method?

The Dispose method in C# is part of the IDisposable interface, and it is used to release unmanaged resources (like file handles, database connections, network sockets, etc.) that a class may hold. Properly disposing of these resources helps prevent memory leaks and ensures that resources are cleaned up promptly.

The garbage collector primarily deals with managed resources, such as memory allocated by the CLR. If our class manages unmanaged resources like file handles, database connections, or COM objects, it’s crucial to implement a custom Dispose method to explicitly free these resources. A custom Dispose method also allows us to control the timing of resource deallocation. This can be very useful in situations where we want to release resources immediately rather than relying on the non-deterministic nature of garbage collection.

Example

Let’s look at an example where we use a class that implements the IDisposable interface and acquires a file handle.

main.cs

example.txt

using System;
using System.IO;
public class CustomResource : IDisposable
{
    private FileStream fileStream;
    private bool disposed = false;
    public CustomResource(string filePath)
    {
        fileStream = new FileStream(filePath, FileMode.OpenOrCreate);
        Console.WriteLine($"Resource acquired for file: {filePath}");
    }
    public void UseResource()
    {
        if (disposed)
            throw new ObjectDisposedException(nameof(CustomResource));
        Console.WriteLine("Reading and printing the content of the file:");
        if (fileStream != null)
        {
            using (var reader = new StreamReader(fileStream))
            {
                string content = reader.ReadToEnd();
                Console.WriteLine(content);
            }
        }
    }
    private void ReleaseUnmanagedResources()
    {
        if (fileStream != null)
        {
            fileStream.Close();
            Console.WriteLine("File handle released.");
        }
    }
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
    private void Dispose(bool disposing)
    {
        if (!disposed)
        {
            if (disposing)
            {
                // Release managed resources
                // (In this example, there are no managed resources to release)
            }
            ReleaseUnmanagedResources();
            disposed = true;
        }
    }
    ~CustomResource()
    {
        Dispose(false);
    }
}
class Program
{
    static void Main()
    {
        using (var customResource = new CustomResource("example.txt"))
        {
            customResource.UseResource();
        }
        // Uncommenting the line below will result in an ObjectDisposedException
        // customResource.UseResource();
    }
}

Explanation

Line 4: Our class implement the IDisposable interface.
Lines 15–30: The UseResource method simulates the usage of the resource. In this case, we use it to read and print the contents of the file example.txt.
Lines 32–39: We use the ReleaseUnmanagedResources to release the unmanaged resources in our code. We acquire a file handle in this case and use this method to close it.
Line 41–45: The public Dispose is the primary method that consumers of our class will use to release resources explicitly.
- We call the private Dispose method with the bool parameter set to true.
- We inform the garbage collector that the finalizer for this object doesn’t need to be called.
Line 47: The private Dispose method is called by both the public Dispose method and the finalizer. It takes a boolean parameter, disposing, which indicates whether the method is being called by user code (true) or by the finalizer (false). This allows us to differentiate between explicit disposal and cleanup during garbage collection. It releases managed (lines 43–44) and unmanaged resources (line 53).
Lines 73 and 75: The CustomResource class acquires an unmanaged resource (a FileStream representing a file handle) when instantiated. We use the customResource object to call the UseResource method. Attempting to use the resource outside the using statement will throw an exception (Line 79).

Calling `Dispose` explicitly

You can call the Dispose method manually when the resource is no longer needed.

In the code shown above, regardless of whether an exception occurs or not, Dispose is being called to ensure that any unmanaged resources held by resource are released.

Why use `Dispose`?

The Dispose method is crucial in scenarios where a class holds unmanaged resources that the garbage collector cannot automatically reclaim. By implementing and calling Dispose, you ensure that such resources are released promptly, improving application performance and stability. This method provides a way to:

Release unmanaged resources: Managed resources are cleaned up by the garbage collector, but unmanaged resources (like file handles, database connections, etc.) need explicit cleanup.
Timely resource management: Relying solely on the garbage collector can lead to delayed cleanup, which may result in resource exhaustion.
Better resource control: Using Dispose provides deterministic cleanup, ensuring that resources are freed as soon as they are no longer needed.

Conclusion

In summary, while .NET’s garbage collector effectively handles managed resources, unmanaged resources require explicit cleanup to ensure efficient resource management. Implementing a custom Dispose method not only allows for precise control over when these resources are released but also enhances the reliability and performance of your application by avoiding potential resource leaks.

Frequently asked questions

Haven’t found what you were looking for? Contact Us

What is Dump method in C#?

In C#, the Dump method, commonly used in LINQPad, displays the contents of an object or collection in an interactive, readable format for debugging or exploration.

What is Dispose and finalize in C#?

In C#, Dispose is used for explicit resource cleanup, while Finalize is a fallback method for releasing unmanaged resources during garbage collection.

What is garbage in C#?

In C#, garbage refers to unused or unreferenced objects in memory that are eligible for cleanup by the garbage collector to free up resources.

Free Resources