Confused. CA1063 is wrong? GC.SuppressFinalize(this)

Question

I have a simple class MyDataClass with a member (obj) that implements IDisposable:

public class MyDataClass : IDisposable
{
    private DisposableObject obj;
    private List<string> list;
    private int c;

    public MyDataClass()
    {
        obj = new DisposableObject();
        list = new List<string>();
        c = 114;
    }

    public void Dispose()
    {
        obj.Dispose();
    }
}

public class DisposableObject : IDisposable
{
    public void Dispose()
    {
        // Free resource
        Console.WriteLine("Dispose DisposableObject");
    }
}

When I run the Code Analysis I get the CA1063 warning which shows me that I should call GC.SuppressFinalize() method in the Dispose() method in MyDataClass implementation.

And I am really confused about this CA1063 warning. Because as far as I know, I should call GC.SuppressFinalize() to indicate to the garbage collector:

"Hey GC, do not worry about this object because I have done already all cleaning work for you!"

So please confirm if I am wrong or not. If I will add the GC.SuppressFinalize() I will get rid of the CA1063 but it will cause that GC will not clean my object. So I will have a memory leak because other class members (managed code) will be not cleaned.

Answer 1

The method GC.SuppressFinalize() indicates to the VM not to run the finalizer. That's the funny looking method in C#:

~MyDataClass()

To remove the warning, you need to either seal your class, or implement the complete IDisposable pattern.

Answer 2

I have the feeling that you are still confused, despite having accepted an answer. Let me explain:

The Garbage Collector (GC) has the unenviable task to remove any objects from memory that are not reachable.

Reachability

An object A is only reachable when there is any chain of references from any GC root to the object. Examples of roots are the stack, and any static fields. So, to determine whether A is reachable, all the GC has to do is to find a reference on the stack that refers to an object that has a reference that refers to an object ... that refers to object A. If it cannot find such a chain, object A is not reachable.¹

So, once the GC has determined that A is not reachable, it will want to remove it from memory. However, before it does that, the GC checks whether A has a finalizer (~A) that must be run. If not, it removes A from memory and the GC is done with it.

Finalization

However, if A has a finalizer that must be run, it cannot remove the object from memory before the finalizer is finished. So, it adds a reference to A to the finalizer queue and does not remove the object from memory (yet). Now the Garbage Collector is done with A for now. However, when the GC runs again, it will again try to determine whether A is reachable. Luckily, the finalizer queue is also one of the Garbage Collector's roots, so it determines that there is a reference from the finalizer queue to A, therefore A is reachable and will again not be removed from memory.

Along comes the finalizer thread, a thread that periodically checks whether there are any objects in the finalizer queue. If there are, it picks one and runs its finalizer method. Eventually, the finalizer thread will run the finalizer of A. Once this is done, the reference to A is removed from the finalizer queue.

Clean up

Then, some time later, the Garbage Collector runs again, and tries to determine again whether A is reachable. As it is now not referenced anywhere, not even from the finalizer queue, A is not reachable. The GC removes A from memory.

---

You see, normally the GC can remove unreachable objects in the same collection cycle it detects them, but when an object has a finalizer that needs to be run, it can take multiple cycles for the object to be collected. Therefore CA1063 recommends you to put GC.SuppressFinalize() in the Dispose method to let the GC know that the objects does not need to be finalized before it is removed from memory. So, the object is always² removed from memory eventually.

Note that when you don't have a finalizer you don't have to add GC.SuppressFinalize(), so in that respect the CA1063 warning is a bit superfluous.

More in-depth information about the Garbage Collector can be found in this MSDN article.

---

¹) Reachability is the reason why it is common to set references to null after disposing them. This makes the referenced object most likely unreachable, and therefore a candidate to be removed.

²) It is possible (but certainly not recommended) to resurrect A by using the finalizer to add a reference to A from another reachable object or root (e.g. a static field). This makes A reachable again, and the Garbage Collector will not remove it. However, its finalizer will not run again, as it has already been invoked once.