----------
2018-11-05
Dispose

also ref to : GC.SuppressFinalize.txt


Example1: Implementing Dispose for a base class

The following example shows the recommended design pattern for implementing a Dispose method for classes that encapsulate unmanaged resources.It defines a DisposableResource class that wraps a Stream object that is passed to its class constructor.The lifetime of the Stream object does not exceed the lifetime of the DisposableResource instance.Because the Stream class implements IDisposable, the DisposableResource class must also provide an implementation.It does not need a finalizer because it does not directly create a native resource such as a file handle or allocate memory in the unmanaged heap.

Resource classes are typically derived from complex native classes or APIs and must be customized accordingly.Use this code pattern as a starting point for creating a resource class and provide the necessary customization based on the resources you are encapsulating.

using System;
using System.IO;

class Program
{

    static void Main()
    {
        try
        {
            // Initialize a Stream resource to pass 
            // to the DisposableResource class.
            Console.Write("Enter filename and its path: ");
            string fileSpec = Console.ReadLine();
            FileStream fs = File.OpenRead(fileSpec);
            DisposableResource TestObj = new DisposableResource(fs);

            // Use the resource.
            TestObj.DoSomethingWithResource();

            // Dispose the resource.
            TestObj.Dispose();

        }
        catch (FileNotFoundException e)
        {
            Console.WriteLine(e.Message);
        }
    }
}


// This class shows how to use a disposable resource.
// The resource is first initialized and passed to
// the constructor, but it could also be
// initialized in the constructor.
// The lifetime of the resource does not 
// exceed the lifetime of this instance.
// This type does not need a finalizer because it does not
// directly create a native resource like a file handle
// or memory in the unmanaged heap.

public class DisposableResource : IDisposable
{

    private Stream _resource;  
    private bool _disposed;

    // The stream passed to the constructor 
    // must be readable and not null.
    public DisposableResource(Stream stream)
    {
        if (stream == null)
            throw new ArgumentNullException("Stream in null.");
        if (!stream.CanRead)
            throw new ArgumentException("Stream must be readable.");

        _resource = stream;

        _disposed = false;
    }

    // Demonstrates using the resource. 
    // It must not be already disposed.
    public void DoSomethingWithResource() {
        if (_disposed)
            throw new ObjectDisposedException("Resource was disposed.");

        // Show the number of bytes.
        int numBytes = (int) _resource.Length;
        Console.WriteLine("Number of bytes: {0}", numBytes.ToString());
    }


    public void Dispose() 
    {
        Dispose(true);

        // Use SupressFinalize in case a subclass
        // of this type implements a finalizer.
        GC.SuppressFinalize(this);      
    }

    protected virtual void Dispose(bool disposing)
    {
        // If you need thread safety, use a lock around these 
        // operations, as well as in your methods that use the resource.
        if (!_disposed)
        {
            if (disposing) {
                if (_resource != null)
                    _resource.Dispose();
                    Console.WriteLine("Object disposed.");
            }

            // Indicate that the instance has been disposed.
            _resource = null;
            _disposed = true;   
        }
    }
}


Example2: Implementing Dispose for a derived class
The following example shows the recommended design pattern for implementing the Dispose method for a subclass of a base class that implements IDisposable

using System;
using System.IO;

public class Example
{
   public static void Main()
   {
      try {
         Console.Write("Enter filename and its path: ");
         string fileSpec = Console.ReadLine();

         DisposableResource2 TestObj = new DisposableResource2(fileSpec);

         // Use the resource.
         TestObj.DoSomethingWithResource();

         // Dispose the resource.
         TestObj.Dispose();
      }
      catch (FileNotFoundException e) {
         Console.WriteLine(e.Message);
      }
   }
}

public class DisposableResource2 : DisposableResource
{
   private bool _disposed;

   public DisposableResource2(string filename) 
                             : base(new FileStream(filename, FileMode.Open)) 
   { }

   private DisposableResource2(Stream s) : base(s)
   { }

   protected override void Dispose(bool disposing)
   {
      Console.WriteLine("Derived class Dispose(disposing) method");
      if (! _disposed) {
         if (disposing) {
            // Dispose of any managed resources of the derived class here.

            // Call the base class implementation.
            base.Dispose(disposing);

            _disposed = true;
         }
         // Dispose of any unmanaged resources of the derived class here.
      }
   } 
}

// A base class that implements the Dispose pattern.
public class DisposableResource : IDisposable
{
    private Stream _resource;
    private bool _disposed;

    public DisposableResource(Stream stream) 
    {
        // Ensure stream is non-null and readable.   
        if (stream == null)
            throw new ArgumentNullException("Stream is null.");

        if (! stream.CanRead)
            throw new ArgumentException("Stream must be readable.");

        _resource = stream;
        _disposed = false;
    }

    // Method that uses the resource.
    public void DoSomethingWithResource()
    {
        // The resource must not already be disposed.
        if (_disposed)
            throw new ObjectDisposedException("Resource was disposed.");

        // Show the number of bytes.
        Console.WriteLine("Number of bytes: {0}", _resource.Length);
    }

    public void Dispose() 
    {
        Dispose(true);

        // Call SupressFinalize in case a subclass implements a finalizer.
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (! _disposed) {
            // If you need thread safety, use a lock around these 
            // operations, as well as in your methods that use the resource.
            if (disposing) {
                // Free the necessary managed disposable objects.
                if (_resource != null) {
                   _resource.Dispose();
                   Console.WriteLine("Object disposed.");
                }
            }

            // Free unmanaged resources.
            _resource = null;
            // Indicate that the instance has been disposed.
            _disposed = true;
        }
    }
}