ant2009 ant2009 - 2 months ago 26
C# Question

Finalize/Dispose pattern in C#

C# 2008

I have been working on this for a while now, and I am still confused about some issues. My questions are below


  1. I know that you only need a finalizer if you are disposing of unmanaged resources. However, if you are using managed resources that make calls to unmanaged resources, would you still need to implement a finalizer?

  2. However, if you develop a class that doesn't use any unmanaged resources, directly or indirectly, can you implement the
    IDisposable
    so that clients of your class can use the 'using statement'?

    Would it be acceptable to implement the IDisposable just so that clients of your class can use the using statement?

    using(myClass objClass = new myClass())
    {
    // Do stuff here
    }

  3. I have developed this simple code below to demonstrate the Finalize/dispose pattern:

    public class NoGateway : IDisposable
    {
    private WebClient wc = null;

    public NoGateway()
    {
    wc = new WebClient();
    wc.DownloadStringCompleted += wc_DownloadStringCompleted;
    }


    // Start the Async call to find if NoGateway is true or false
    public void NoGatewayStatus()
    {
    // Start the Async's download
    // Do other work here
    wc.DownloadStringAsync(new Uri(www.xxxx.xxx));
    }

    private void wc_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
    {
    // Do work here
    }

    // Dispose of the NoGateway object
    public void Dispose()
    {
    wc.DownloadStringCompleted -= wc_DownloadStringCompleted;
    wc.Dispose();
    GC.SuppressFinalize(this);
    }
    }



Question about the source code:


  1. Here I have not added the finalizer, and normally the finalizer will be called by the GC, and the finalizer will call the Dispose. As I don't have the finalizer, when do I call the Dispose method? Is it the client of the class that has to call it?

    So my class in the example is called NoGateway and the client could use and dispose of the class like this:

    using(NoGateway objNoGateway = new NoGateway())
    {
    // Do stuff here
    }


    Would the Dispose method be automatically called when execution reaches the end of the using block, or does the client have to manually call the dispose method? i.e.

    NoGateway objNoGateway = new NoGateway();
    // Do stuff with object
    objNoGateway.Dispose(); // finished with it

  2. I am using the webclient class in my
    NoGateway
    class. Because the webclient implements the IDisposable interface, does this mean that the webclient indirectly uses unmanaged resources? Is there a hard and fast rule to follow about this? How do I know that a class uses unmanaged resources?


Answer

The recommended IDisposable pattern is here. When programming a class that uses IDisposable, generally you should use two patterns:

When implementing a sealed class that doesn't use unmanaged resources, you simply implement a Dispose method as with normal interface implementations:

public sealed class A : IDisposable
{
    public void Dispose()
    {
        // get rid of managed resources, call Dispose on member variables...
    }
}

When implementing an unsealed class, do it like this:

public class B : IDisposable
{    
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (disposing)
        {
            // get rid of managed resources
        }   
        // get rid of unmanaged resources
    }

    // only if you use unmanaged resources directly in B
    //~B()
    //{
    //    Dispose(false);
    //}
}

Notice that I haven't declared a finalizer in B; you should only implement a finalizer if you have actual unmanaged resources to dispose. The CLR deals with finalizable objects differently to non-finalizable objects, even if SuppressFinalize is called.

So, you shouldn't declare a finalizer unless you have to, but you give inheritors of your class a hook to call your Dispose and implement a finalizer themselves if they use unmanaged resources directly:

public class C : B
{
    private IntPtr m_Handle;

    protected override void Dispose(bool disposing)
    {
        if (disposing)
        {
            // get rid of managed resources
        }
        ReleaseHandle(m_Handle);

        base.Dispose(disposing);
    }

    ~C() {
        Dispose(false);
    }
}

If you're not using unmanaged resources directly (SafeHandle and friends doesn't count, as they declare their own finalizers), then don't implement a finalizer, as the GC deals with finalizable classes differently, even if you later suppress the finalizer. Also note that, even though B doesn't have a finalizer, it still calls SuppressFinalize to correctly deal with any subclasses that do implement a finalizer.

When a class implements the IDisposable interface, it means that somewhere there are some unmanaged resources that should be got rid of when you've finished using the class. The actual resources are encapsulated within the classes; you don't need to explicitly delete them. Simply calling Dispose() or wrapping the class in a using(...) {} will make sure any unmanaged resources are got rid of as necessary.