How free memory used by a large list in C#?

Question

I have a list called Population , is a great list of very many positions and at some point I stop using it. How I can free the resources? Then this is part of the code:

 private List <BasePopulation> Population=new List <BasePopulation>();
 Population.SomeMethod();
 Population.Clear();

I used the Clear method, but not works. Any idea?

Answer 1

The problem may be that Clear is not doing what you think it is. Clear simply marks the List as being empty without resizing the internal array that it uses behind the scenes. It will, however, remove all references to the individual BasePopulation instances. So if no other data structure has a reference to them they will be eligible for garbage collection. But, it will not reduce the size of the List directly. I just verified this using ILSpy.

You have two options.

1. Set Population = null . This will unroot the entire object instance making it eligible for garbage collection.

2. Call TrimExcess on this List . This will resize the internal array.

Answer 2

Well, since the garbage collector (GC) is taking care of the memory management for you, the first thing you can do is getting rid of all references to the list (and the contained elements) so that the GC is able to remove it on the next occasion. You can do this, for example, by explicitly setting

Population = null;

If this isn't enough for you, for example because you're really eager to get rid of the objects now and you can accept non-optimal run-time behaviour, you can tell the GC to start collecting objects now via

GC.Collect();

More information about this method can be found here .

As indicated above, this practice can induce a performance penalty since it forces the GC to clean up resources at a point in the program where it usually wouldn't. Directly calling the method is thus often discouraged, but it might serve your needs if this is really a special point in your application. As a practical example, I've successfully improved peak memory usage in a program that requires a lot of objects during an initialization that can be discarded once the actual program execution has started. Here, the small performance penalty for calling GC.Collect() after the initialization was justifiable.

Answer 3

The best possible thing you could do is nothing. Garbage Collector GC does this job automatically for you. Since List is not IDisposable you cannot dispose it.

Clear would simply remove elements from the List but wouldn't dispose it.

Answer 4

You must clear the list, and after that invoke the GC to remove it from memory. As follows with extensive method:

public static void ClearMemory<T>(this List<T> lista)
{
    int identificador = GC.GetGeneration(lista);
    lista.Clear();
    GC.Collect(identificador, GCCollectionMode.Forced);
}

Answer 5

Edit, rewording my answer about Disposing. Ok, I must have been imagining things when I typed Clean. I'm assuming that if clearing all of the items from your list is not free resources, then the resources you are trying to free up are unmanaged. Based upon that assumption you'll need BasePopulation to implement IDisposable so when that object gets picked up by the garbage collector, those resources can then be released.

http://msdn.microsoft.com/en-us/library/system.idisposable.aspx