In the Dotnet CLR maintains the Heap. It stores the Objects 
which are recently used in the Top of the Heap. By using 
this GC identifies the objects which are recently used and 
which are not in use.

Garbage Collector identifies a unused object using "referce 
counting" 
reference countiing: how many times the object is used 
if the count is zero..its is unuesd....now the gc will 
release the resources..

C# makes use of the Finilize() destructor for this purpose. 
The CLR periodically checks the entire program for unused 
objects using the refrence tracing garbage collector which 
in turn invokes he Finilze() destructor to relese the 
memory of such objects.

GC identifies the objects which are not in use by the use 
of generations. Whenever a new object is created or deleted 
GC sweeps the heap by moving the variables to different 
generations, and finally destructs the objects whichever 
belongs to generation 0.

Garbage Collector determines which objects are no longer 
being used by examining the application's roots. In Dot Net 
each and every application has a set of roots. Each root 
either refers to an object on the managed heap or is set to 
null. An application's roots include global and static 
object pointers, local variables and reference object 
parameters on a thread's stack, and CPU registers. The 
garbage collector has access to the list of active roots 
that the just-in-time (JIT) compiler and the runtime 
maintain. Using this list, it examines an application's 
roots, and in the process creates a graph that contains all 
the objects that are reachable from the roots. Objects that 
are not in the graph are unreachable from the application's 
roots. The garbage collector considers unreachable objects 
as garbage and not in use.