Интерфейс IDisposable имеет вид:

public interface IDisposable
{
   void Dispose();
}

и соответствующий класс:

public class MyClass : IDisposable
{
    public void Dispose()
    {
        // Perform any object clean up here.

        // If you are inheriting from another class that
        // also implements IDisposable, don't forget to
        // call base.Dispose() as well.
    }
}

Неявная очистка (Implicit cleanup)

Неявная очистка должна быть реализована везде, где это возможно, путем защиты ресурсов с помощью SafeHandle. В .NET 1.1 этого класса не существовало, поэтому раньше необходимо было реализовывать финализатор. В последних версиях .NET необходимость реализовывать финализаторы практически отпала. Если такая необходимость все же есть, то можно реализовать protected Finalize метод используя синтаксис используемого языка. Исполняемая среда (runtime) вызовет метод Finalize как часть процесса финализации GC.

Не нужно реализовывать финализаторы кроме крайних случаев. Процесс их написания сложный и сделает использование вашего класса более дорогостоящим (expensive) даже если он ни разу не выполнится.  Все объекты, которые реализуют финализаторы должны быть включены в список объектов финализации (finalization queue), который обслуживает GC. Поэтому если вам необходимо освободить ресурсы используйте Dispose метод, а не финализаторы. Если финализатор вам нужен, используйте его в дополнение методу Dispose, а не вместо него.

Синтаксические различия финализаторов и деструкторов:

Dispose Pattern

Без использования финализатора:

public class SimpleCleanup : IDisposable
{
    // some fields that require cleanup
    private SafeHandle handle;
    private bool disposed = false; // to detect redundant calls

    public SimpleCleanup()
    {
        this.handle = /*...*/;
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!disposed)
        {
            if (disposing)
            {
                if (handle != null)
                {
                    handle.Dispose();
                }
            }

            disposed = true;
        }
    }

    public void Dispose()
    {
        Dispose(true);
    }
}

C использованием финализатора:

public class ComplexCleanupBase : IDisposable
{
    // some fields that require cleanup
    private bool disposed = false; // to detect redundant calls

    public ComplexCleanupBase()
    {
        // allocate resources
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!disposed)
        {
            if (disposing)
            {
                // dispose-only, i.e. non-finalizable logic
            }

            // shared cleanup logic
            disposed = true;
        }
    }

    ~ComplexCleanupBase()
    {
        Dispose(false);
    }

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

public class ComplexCleanupExtender : ComplexCleanupBase
{
    // some new fields that require cleanup
    private bool disposed = false; // to detect redundant calls

    public ComplexCleanupExtender() : base()
    {
        // allocate more resources (in addition to base’s)
    }

    protected override void Dispose(bool disposing)
    {
       if (!disposed)
       {
            if (disposing)
            {
                // dispose-only, i.e. non-finalizable logic
            }

            // new shared cleanup logic
            disposed = true;
        }

        base.Dispose(disposing);
    }
}

Более подробно нюансы реализации и использования финализаторов и деструкторов можно здесь и здесь.