C# 4 and .NET 4

312 ❘ ChaPTer 13 memOry mAnAGement And pOinters
Generally, the garbage collector runs when the .NET runtime determines that garbage
collection is required. You can force the garbage collector to run at a certain point in
your code by calling System.GC.Collect(). The System.GC class is a .NET class
that represents the garbage collector, and the Collect() method initiates a garbage
collection. The GC class is intended for rare situations in which you know that it’s a
good time to call the garbage collector; for example, if you have just de-referenced
a large number of objects in your code. However, the logic of the garbage collector
does not guarantee that all unreferenced objects will be removed from the heap in a
single garbage collection pass.
When the garbage collector runs, it actually hurts the performance of your application as it is impossible for
your application to continue running while the garbage collector fi nishes its tasks. Use the .NET garbage
collector to make this less of a problem, as it is a generational garbage collector .
When objects are created, they are placed within the managed heap. The fi rst section of the heap is called
the generation 0 section or gen 0. As your new objects are created, they are moved into this section of the
heap. Therefore, this is where the youngest objects reside.
Your objects are there until the fi rst collection of objects occurs through the garbage collection process.
The objects that remain alive after this cleansing are compacted and then moved to the next section or
generational part of the heap — the generation 1 or gen 1 section.
At this point, the generation 0 section is empty, and all new objects are again placed in this section.
Older objects that survived the GC (garbage collection) process are found further down in the generation
1 section. This movement of aged items actually occurs one more time. The next collection process that
occurs is then repeated. This means that the items that survived the GC process from the generation
1 section are moved to the generation 2 section, and the gen 0 items go to gen 1, again leaving gen 0 open
for new objects.
It is interesting to note that a garbage collection will occur when you allocate an item
that exceeds the capacity of the generation 0 section or when a GC.Collect() is called.
This process greatly improves the performance of your application. It is generally observed that your
youngest objects are usually the ones that can be collected and that there are a large number of younger -
related objects that might be reclaimed as well. If these objects reside next to each other in the heap, then
the garbage collection process will be faster. In addition, the fact that related objects are residing next to
each other will also make program execution faster all around.
Another area in the performance realm of garbage collection in .NET is in how the framework deals with
larger objects that go onto the heap. Under the covers of .NET, larger objects have their own managed heap,
referred to as the Large Object Heap. When objects greater than 85,000 bytes are utilized, they go to this
special heap rather than the main heap. Your .NET application doesn ’ t know the difference, as this is all
managed for you. The reason for this is that compressing large items in the heap is expensive and therefore
isn ’ t done for the objects residing in the Large Object Heap.
freeing unmanaged resourCes
The presence of the garbage collector means that you will usually not worry about objects that you no
longer need; you will simply allow all references to those objects to go out of scope and allow the garbage
collector to free memory as required. However, the garbage collector does not know how to free unmanaged
resources (such as fi le handles, network connections, and database connections). When managed classes
www.it-ebooks.info