Setting objects to nothing

Question

This is something i seeem to get a different answer for, every time i ask a developer. So i thought it would be a good question for the overflow to see what everyone does.

If you have a sqlClient.sqlconnection object, in the cleanup code (finally block etc) do you dispose of the object or do you set it to nothing, or both?

I've always just called the dispose, and allowed the garbage collector to do its thing...

Answer 1

You don't need to set the variable to Nothing, just disposing is enough.

Answer 2

Jeff Atwood had a recent blog post on this...

It seems it's not really necessary unless you don't trust the garbage collector. I've stopped doing this altogether and most often use the "using" syntax which is clean and easy to understand.

Answer 3

You're basically doing the right thing. After you call .Dispose(), you can be sure that the resources allocated by the connection are cleaned up. Then, as soon as the SqlConnection object you declared in code goes out of scope, the GC will clean up that memory as well.

If you'd like to prod the GC, you can always call its .Collect() method.

Answer 4

If you open up the code with the "= Nothing" in reflector you will see that the compiler has (usually) removed/optimized the statement.

Now if you do a check like this.

If myObject IsNot Nothing Then
  myObject = Nothing
End If

The compiler may not optimize this away, and this will cause you to hold a reference to myObject longer then necessary, causing the object to wait longer than necessary to be eligible for GC.

Ideally, you should dispose the object asap and leave it alone.

Answer 5

If the type has a Dispose use that.

If the type does not have a Dispose, and it holds on to large amounts of memory, then setting the reference to nothing before performing some slow operation (rather than holding on to it) can help avoid "mid life crisis".

However the compilers have become better at optimising this case and releasing the reference well before the end of the block.

Answer 6

Have a look at my answer to a similar question. Setting a variable to null/Nothing is very rarely necessary. Calling Dispose is necessary.

Answer 7

I always ensure to dispose them off by employing an 'using' block but never set them to null. MSDN also does not ask us to do this.

I will be happy to learn any reasons others have to explicitly set the ref to null. Using the object after disposing would anyway throw an 'ObjectDisposedException' so accidental usage after dispose cannot be a reason.

Answer 8

I agree, disposing is mandatory as long as the object implements a dispose() method you have to call it, because when some object implements a dispose() method it means that he can't count on the GC to free the resources that he has been using (i.e. he is using unmanaged resources) in this case, yes you have to call dispose in order to release these unmanaged resources. about setting the reference to null, it's not necessary, but it's still a good programming practice no doubt. The really interesting thing here is, can anyone use a disposed object or an object with no references (i.e can a dead (or rather about to die) objects resurrect? Take a look at the following:

public class Employee {

    public static Employee emp;

    public string Name { get; set; }
    public string Position { get; set; }

    public override string ToString() {
        return String.Format("{0} works as {1}", Name, Position);
    }

    ~Employee() {
        emp = this;
    }
}