Question

What is the diference between those two examples of code?

  public Test(int x)
  {
        List<int> list= new List<int>();
        List<int> list1 = new List<int>();

        list= CreateList(x);
        list1 = CreateList(x + 1);

        DoStuff(list, list1);

        list.Clear();
        list = null;
        list1.Clear();
        list1 = null;
    } 

Is this the way to code?

    public Test(int nCount)
    {
        var list = CreateList(nCount);
        var list1 = CreateList(nCount + 1);

        DoStuff(list, list1);
    }

Answer 1

Nothing.

For readability and therefore future maintenance reasons, use the second one. It’s clearly much easier to understand, and because of the design of C# and the CLR, much of the code in your first example is not required.

I’ll try to explain what I mean. You don’t need to clear or set to null any references to local variables (the garbage collector will do this for you). You only need to do this for class-level fields, and often not even then (again, the garbage collector will collect them when your class goes out of scope).

Consider focussing more on the concept of objects being disposable, and don’t worry about the memory usage/garbage collection aspects. Emptying a list or setting the reference to the list to null doesn’t actually reclaim memory; the memory is still allocated until the garbage collector reclaims it at some indeterminate time in the future.

There are means to force a garbage collection, but typically that means you’re doing something wrong if you need to go that far. Some would say if you need to worry about memory in so much detail, .NET may not be the correct choice of language for your problem domain.

Also, using var or specifying the type explicitly makes no difference whatsoever.