The IDisposable pattern isn't one of the a classic patterns. It's a pattern suggested in
MSDN to implement the IDisposable interface. You should be familiar with the pattern
or with the interface because it's a basic thing to know about the .Net framework.

How to Use IDisposable Pattern
Lets look at a code example.

    public class DisposeObject : IDisposable
    {
        #region Members
 
        private bool _disposed = false;
 
        #endregion
 
        #region IDisposable Members
 
        ~DisposeObject()
        {
            Dispose(false);
        }
 
        /// <summary>
        /// Dispose the current object
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
        }
 
        private void Dispose(bool disposing)
        {
            if (!_disposed)
            {
                if (disposing)
                {
                    // clean up resources
                    CleanUp();
 
                    // The object will be cleaned up only if the method
                    // gets true - we are in the Dispose method.
                    // Therefore, you should call GC.SupressFinalize to
                    // take this object off the finalization queue
                    // and prevent finalization code for this object
                    // from executing a second time. 
                    // Taken from MSDN.
                    GC.SuppressFinalize(this);
                }
 
                // dispose occurred
                _disposed = true;
            }
        }
 
        private void CleanUp()
        {
            // put here the code to dispose all managed
            // and unmanaged resources
        }
 
        #endregion
    }