we use different dispose pattern in different situations.

• Basic Dispose Pattern

public class DisposableResourceHolder : IDisposable {
 
    private SafeHandle resource; // handle to a resource

    public DisposableResourceHolder(){
        this.resource = ... // allocates the resource
    }

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

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

Use a basic dispose pattern when the type has members implementing IDisposable interface, which are treated as managed resource.

• Dispose Pattern with Finalizer

public class ComplexResourceHolder : IDisposable {
 
    private IntPtr buffer; // unmanaged memory buffer
    private SafeHandle resource; // disposable handle to a resource
        
    public ComplexResourceHolder(){
        this.buffer = ... // allocates memory
        this.resource = ... // allocates the resource
    }

    protected virtual void Dispose(bool disposing){
            ReleaseBuffer(buffer); // release unmanaged memory
        if (disposing){ // release other disposable objects
            if (resource!= null) resource.Dispose();
        }
    }
 
    ~ ComplexResourceHolder(){
        Dispose(false);
    }
 
    public void Dispose(){
        Dispose(true);
        GC.SuppressFinalize(this);
    }
}

Add a finalizer if the type has unmanaged resource. Users could call Dispose() manually in most situations when the resource needs to be released. And the finalizer assures it when users "forget" to do this.