IDisposable Interface in C#

IDisposable is an interface defined in the System namespace that contains a single method, Dispose.

The purpose of this interface is to provide an explicit way to release unmanaged resources in a deterministic manner, ensuring that these resources are released as soon as they are no longer needed.

In C#, the Garbage Collector handles the memory allocated to objects once they are no longer needed. However, there are unmanaged resources, such as database connections, files, sockets, etc., that are not automatically managed by the Garbage Collector.

If not released properly, these resources can cause memory leaks and other performance issues. Implementing IDisposable allows developers to release these resources explicitly and in a controlled manner.

The IDisposable interface provides a way to release these unmanaged resources explicitly, allowing for better resource management in an application.

IDisposable Interface

The IDisposable interface is defined as follows:

namespace System
{
    public interface IDisposable
    {
        void Dispose();
    }
}

When a class implements IDisposable, it commits to providing an implementation of the Dispose method, in which unmanaged resources will be released.

Basic Example

Suppose we have a class that handles a file. We want to ensure that the file is closed properly when it is no longer needed.

We implement IDisposable to achieve this:

public class FileHandler : IDisposable
{
    private FileStream _file;

    public FileHandler(string path)
    {
        _file = new FileStream(path, FileMode.OpenOrCreate);
    }

    public void Write(string message)
    {
        byte[] info = new UTF8Encoding(true).GetBytes(message);
        _file.Write(info, 0, info.Length);
    }

    public void Dispose()
    {
        _file?.Close();
        _file?.Dispose();
    }
}

Using with using

To simplify the call to Dispose, C# provides the using statement, which ensures that Dispose is called automatically at the end of the using block:

using (var handler = new FileHandler("file_path.txt"))
{
    handler.Write("Hello, world!");
}

Using GC.SuppressFinalize

When Dispose is called explicitly, it is a good practice to use GC.SuppressFinalize to prevent the garbage collector from calling the finalizer, thus optimizing performance.

Advanced Implementation with Finalizer

In some cases, it is necessary to release both managed and unmanaged resources. To do this, a more advanced disposal pattern that combines Dispose and a finalizer can be implemented:

public class AdvancedResource : IDisposable
{
    private IntPtr _unmanagedResource;
    private bool _disposed = false;

    public AdvancedResource(IntPtr resource)
    {
        _unmanagedResource = resource;
    }

    ~AdvancedResource()
    {
        Dispose(false);
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!_disposed)
        {
            if (disposing)
            {
                // Release managed resources
            }
            // Release unmanaged resources
            if (_unmanagedResource != IntPtr.Zero)
            {
                // Release the unmanaged resource
                _unmanagedResource = IntPtr.Zero;
            }
            _disposed = true;
        }
    }
}