C# 4 and .NET 4

freeing Unmanaged resources ❘ 315
// do your processing
}
finally
{
if (theInstance != null)
{
theInstance.Dispose();
}
}
This version ensures that Dispose() is always called on theInstance and that any resources consumed by
it are always freed, even if an exception occurs during processing. However, it would make for confusing
code if you always had to repeat such a construct. C# offers a syntax that you can use to guarantee that
Dispose() will automatically be called against an object that implements IDisposable when its reference
goes out of scope. The syntax to do this involves the using keyword — though now in a very different
context, which has nothing to do with namespaces. The following code generates IL code equivalent to the
try block just shown:
using (ResourceGobbler theInstance = new ResourceGobbler())
{
// do your processing
}
The using statement, followed in brackets by a reference variable declaration and instantiation, will cause
that variable to be scoped to the accompanying statement block. In addition, when that variable goes out
of scope, its Dispose() method will be called automatically, even if an exception occurs. However, if you
are already using try blocks to catch other exceptions, it is cleaner and avoids additional code indentation
if you avoid the using statement and simply call Dispose() in the Finally clause of the existing try block.
For some classes, the notion of a Close() method is more logical than Dispose(); for
example, when dealing with fi les or database connections. In these cases, it is common
to implement the IDisposable interface and then implement a separate Close()
method that simply calls Dispose(). This approach provides clarity in the use of your
classes but also supports the using statement provided by C#.
implementing idisposable and a destructor
The previous sections discussed two alternatives for freeing unmanaged resources used by the classes
you create:
➤
➤
The execution of a destructor is enforced by the runtime but is nondeterministic and places an
unacceptable overhead on the runtime because of the way garbage collection works.
T h e IDisposable interface provides a mechanism that allows users of a class to control when
resources are freed but requires discipline to ensure that Dispose() is called.
In general, the best approach is to implement both mechanisms to gain the benefi ts of both while
overcoming their limitations. You implement IDisposable on the assumption that most programmers
will call Dispose() correctly, but implement a destructor as a safety mechanism in case Dispose() is not
called. Here is an example of a dual implementation:
using System;
public class ResourceHolder: IDisposable
{
private bool isDisposed = false;
www.it-ebooks.info