c# - doubts regarding Memory management in .net

I'm learning about Memory management in C# from the book "Professional C#"

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 file
handles, network connections, and
database connections). When managed
classes encapsulate direct or indirect
references to unmanaged resources, you
need to make special provision to
ensure that the unmanaged resources
are released when an instance of the

class is garbage collected.

When defining a class, you can use
two mechanisms to automate the freeing
of unmanaged resources.

1. Declaring a destructor (or finalizer) as a member of your class.


2. Implementing the System.IDisposable interface in your
   class.

I didn't understand few things:

1. "unmanaged resources (such as file handles, network connections, and database connections)". Whats the big deal about them? How come they are unmanaged? (or) Why can't GC managed these resources?




2. What code would we place in finalizer or Dispose() method of the a class and what exactly that code would look like? Some examples using these resources, would be of lot of help.

Answer

The real question here is about urgency. As the garbage collector explicitly tracks memory, it will know when there is a need to free up memory by cleaning unreferenced objects. This can happen several times a minute, or once an hour, or even never (if no new objects needs to be created). But the important thing is that it does happen when needed.

But memory isn't the only resource that is limited. Take files. Usually only one application at a time can open a file as it can become messy if several people tries to write to the same file. Databases have a limited amount of connections. And so on. The garbage collector doesn't track any of these resources. And it has no idea of how urgent it is to close them.

Sure, you could open a FileStream and read from it without closing it afterwards. if you null out the reference to the object, eventually the garbage collector will probably decide to collect the FileStream object, which will have its Finalizer run and the file will get properly closed. But that could take a long time, and in the meanwhile the file is locked.

With database connections it is far more urgent, as there is a very limited amount of collections available, so if you open too many connections without disposing of them you will eventually get an error as you will have a bunch of database objects having open connections that lie waiting in the garbage collector queue.

Properly disposing of Disposable object is therefore good practice. Sometimes you could get away not doing so, but it is poor style. If an object implements IDisposable, it is because it wants you to clean it up when you are done using it.