Once you have to do that more often, you may welcome a set of (simple enough) helper methods:

[DebuggerStepThrough]
public static void Dispose(IDisposable id)
{
if (id != null)
{
id.Dispose();
}
}

[DebuggerStepThrough]
public static void Dispose(object o)
{
IDisposable disposable = o as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}

public static void Dispose<T>(ref T o)
{
IDisposable disposable = o as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
o = default(T);
}

[DebuggerStepThrough]
public static void DisposeElements(IEnumerable enumerable)
{
if (enumerable != null)
{
IEnumerator enumerator = enumerable.GetEnumerator();
while (enumerator.MoveNext())
{
Dispose(enumerator.Current);
}
}
}

With this your Dispose(bool) method would look like this:

protected virtual void Dispose(bool disposing)
{
if (disposing)
MyHelper.DisposeElements(_ListofB);
}

HIH, AJ.NET

class A:IDisposable
{
private List _ListofB;

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

protected virtual void Dispose(bool disposing)
{
if (disposing)
{
foreach (CartItem c in CartItemList)
{
c.Dispose();
}

}
}

}

Sorry abt comment 14. I pressed Submit Comment inadvertently, and thanks for the help

class A
{
private List _ListofB;

}

Regarding the other resources: They are not set to null automatically but you don’t have to do that manually either. Since they are not reachable by a living object, the GC will collect them anyway. Personally I set members to null only after I explicitly disposed them (just as a safety measure). Anyway, the call to GC.SuppressFinalize(this) will not affect any of those objects, i.e. one had a finalizer, it would still be called.

You could of course refrain from using the pattern at all; a simple Unsubscribe() method called instead of Dispose() might be sufficient in your case. In this case you don’t have to bother with a finalizer and GC.SuppressFinalize(this) at all. After all, the primary purpose for finalizers is dealing with unmanaged resources (if only referenced indirectly).

Great article. I want your input on this particular case I have.

I have a class (A) that holds a reference to another class (B). Class B then subscribes to an event published by another class (C). At some point, class A might not need class B any more, and class B should be GC’ed. However, since class B has subscribed to class C event, it’s not GC’ed.

So, if I write a basic implementation of the IDisposable pattern (like you propose in your blog post here), class A would simply call class B’s dispose method when it is no longer needs class B. The dispose method in class B would then unsubscribe to class C’s event, and then call GC.SuppressFinalize(this).

But, should I call GC.SuppressFinalize(this)?

Class B has a few other managed resources besides the event hook, managed resources like List objects and other objects that class B uses. Are those automatically set to null or do I also have to set those to null manually if I call GC.SuppressFinalize(this)?

Would it, in that case, be better just to unsubscribe to class C’s event in the Displose method and then NOT call GC.SuppressFinalize(this) – having the GC do it’s magic as it would do normally.