What is the correct way to implement IDisposable in C#?

Question

I am trying to implement a iDisposable class in c# but the examples in msdn and stackoverflow do not works for me.

And im running a console application in visual studio 2012 framework 4.0

am I missing some using or what?

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

I am following this examples (hyperlinks dont works for me, dont know why):
http://msdn.microsoft.com/en-us/library/ms244737.aspx
Implementing IDisposable correctly
How to implement IDisposable properly

You are missing the `Dispose(bool)` method, [this article](http://www.codeproject.com/Articles/15360/Implementing-IDisposable-and-the-Dispose-Pattern-P) should help — TomT, Jan 16 '14 at 12:56

score 1 · Answer 1 · edited May 23 '17 at 11:57

1

You can find good explanation here Proper use of the IDisposable interface

The short example:

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

private void Dispose(bool disposing) {
    if (!this.disposed) {
        if (disposing) {
            // clean resources here
        }
        disposed = true;
    }
}

private bool disposed = false;

edited May 23 '17 at 11:57

Community

1
1

answered Jan 16 '14 at 12:59

Pylyp Lebediev

1,991
4
26
44

score 0 · Answer 2 · answered Jan 16 '14 at 12:56

I think this is the standard template more or less:

    private bool disposed = false;

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


    protected virtual void Dispose(bool disposing)
    {

        if(!disposed)
        {

            if(disposing)
            {
                // destroy managed objects here...
            }

            disposed = true;
        }
    }


    ~NameOfClass()
    {
        Dispose(false);
    }

score 0 · Answer 3 · edited May 23 '17 at 12:21

The standard way is to use the Dispose Pattern. See also this.

class MyClass : IDisposable
{
    private bool alreadyDisposed = false;

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

    // This is called by GC automatically at some point if public Dispose() has not already been called
    ~MyClass()
    {
        Dispose(false);
    }

    // Each derived class should implement this method and conclude it with base.Dispose(disposeManagedResourcesAlso)) call
    protected virtual void Dispose(bool disposeManagedResourcesAlso)
    {
        if (alreadyDisposed) return;

        if (disposeManagedResourcesAlso)
        {
            ...dispose managed resources...
        }

        ...dispose unmanaged resources...

        alreadyDisposed = true; 
    }
}

score 0 · Answer 4 · answered Jan 16 '14 at 13:03

    public class MyResource: IDisposable
    {
        // Pointer to an external unmanaged resource. 
        private IntPtr handle;
        // Other managed resource this class uses. 
        private Component component = new Component();
        // Track whether Dispose has been called. 
        private bool disposed = false;

        public MyResource(IntPtr handle)
        {
            this.handle = handle;
        }

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

        protected virtual void Dispose(bool disposing)
        {
            if(!this.disposed)
            {
               if(disposing)
                {
                    // Dispose managed resources.
                    component.Dispose();
                }

                CloseHandle(handle);
                handle = IntPtr.Zero;

                // Note disposing has been done.
                disposed = true;

            }
        }

        // Use interop to call the method necessary 
        // to clean up the unmanaged resource.
        [System.Runtime.InteropServices.DllImport("Kernel32")]
        private extern static Boolean CloseHandle(IntPtr handle);

        ~MyResource()
        {
            // Do not re-create Dispose clean-up code here. 
            // Calling Dispose(false) is optimal in terms of 
            // readability and maintainability.
            Dispose(false);
        }
    }

Source: IDisposable Interface

score 0 · Answer 5 · answered Jan 16 '14 at 13:07

Typical IDisposable implementation could be something like that:

public class Foo: IDisposable {
  ...  

  public Boolean IsDisposed {
    get;
    protected set; // <- Or even "private set"
  }

  protected virtual void Dispose(Boolean disposing) {
    if (IsDisposed)
      return;

    if (disposing) {
      // Release all acquired resources here
    } 

    // You can work with structures (not objects!) here
    // Hardly want you to do anything here...

    IsDisposed = true;
  }

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

What is the correct way to implement IDisposable in C#?

5 Answers5