What is IDisposable in C#: Explained with Examples

IDisposable is an interface in C# that provides a way to release unmanaged resources like files or database connections explicitly. It defines a single method Dispose() that you implement to clean up these resources when you are done using them.

How It Works

Think of IDisposable as a cleanup helper for your program. When your code uses resources like files, network connections, or memory outside of normal control, these resources need to be released properly to avoid problems like memory leaks or locked files.

By implementing IDisposable, you create a method called Dispose() where you put all the cleanup code. When you call Dispose(), it frees those resources immediately instead of waiting for the system to do it later. This is like washing your dishes right after eating instead of leaving them dirty.

This pattern helps keep your program efficient and prevents resource waste, especially in long-running applications.

Example

This example shows a simple class that opens a file and implements IDisposable to close it properly.

csharp

using System;
using System.IO;

class FileManager : IDisposable
{
    private FileStream fileStream;
    private bool disposed = false;

    public FileManager(string filePath)
    {
        fileStream = new FileStream(filePath, FileMode.OpenOrCreate);
        Console.WriteLine("File opened.");
    }

    public void WriteData(string data)
    {
        if (disposed) throw new ObjectDisposedException("FileManager");
        byte[] bytes = System.Text.Encoding.UTF8.GetBytes(data);
        fileStream.Write(bytes, 0, bytes.Length);
        Console.WriteLine("Data written to file.");
    }

    public void Dispose()
    {
        if (!disposed)
        {
            fileStream.Close();
            Console.WriteLine("File closed.");
            disposed = true;
        }
    }
}

class Program
{
    static void Main()
    {
        using (var manager = new FileManager("test.txt"))
        {
            manager.WriteData("Hello IDisposable!");
        }
        // Dispose is called automatically here
    }
}

Output

File opened.
Data written to file.
File closed.

When to Use

Use IDisposable when your class holds resources that need explicit cleanup, such as:

• File handles or streams
• Database connections
• Network sockets
• Unmanaged memory or system resources

Implementing IDisposable ensures these resources are released as soon as you finish using them, preventing resource leaks and improving performance. It is especially important in applications that run for a long time or handle many resources.

Key Points

• IDisposable defines the Dispose() method for cleanup.
• Use using blocks to automatically call Dispose().
• Helps manage unmanaged resources safely and efficiently.
• Prevents resource leaks and locked files or connections.

Key Takeaways

IDisposable lets you clean up resources like files and connections explicitly.

Implement Dispose() to release unmanaged resources when done.

Use using blocks to ensure Dispose() is called automatically.

Proper disposal prevents resource leaks and improves app stability.