C# 4 and .NET 4

freeing Unmanaged resources ❘ 313
encapsulate direct or indirect references to unmanaged resources, you need to make special provisions to
ensure that the unmanaged resources are released when an instance of the class is garbage collected.
When defi ning a class, you can use two mechanisms to automate the freeing of unmanaged resources. These
mechanisms are often implemented together because each provides a slightly different approach to the
solution of the problem. The mechanisms are:
➤
➤
Declaring a destructor (or fi nalizer) as a member of your class
Implementing the System.IDisposable interface in your class
The following sections discuss each of these mechanisms in turn, and then look at how to implement them
together for best effect.
destructors
You have seen that constructors allow you to specify actions that must take place whenever an instance of
a class is created. Conversely, destructors are called before an object is destroyed by the garbage collector.
Given this behavior, a destructor would initially seem like a great place to put code to free unmanaged
resources and perform a general cleanup. Unfortunately, things are not so straightforward.
Although we talk about destructors in C#, in the underlying .NET architecture these
are known as fi n a l i z er s . When you defi ne a destructor in C#, what is emitted into the
assembly by the compiler is actually a Finalize() method. It doesn’t affect any of
your source code, but you need to be aware of it when examining the content of an
assembly.
The syntax for a destructor will be familiar to C++ developers. It looks like a method, with the same name
as the containing class, but prefi xed with a tilde ( ~ ). It has no return type, and takes no parameters and no
access modifi ers. Here is an example:
class MyClass
{
~MyClass()
{
// destructor implementation
}
}
When the C# compiler compiles a destructor, it implicitly translates the destructor code to the equivalent
of a Finalize() method, which ensures that the Finalize() method of the parent class is executed. The
following example shows the C# code equivalent to the Intermediate Language (IL) that the compiler would
generate for the ~MyClass destructor:
protected override void Finalize()
{
try
{
// destructor implementation
}
finally
{
base.Finalize();
}
}
www.it-ebooks.info