Part IV in C#.NET

Print PDF-417 2d barcode in C#.NET Part IV

To make things simpler for developers, the System.Runtime.ConstrainedExecution namespace defines a CriticalFinalizerObject class that looks like this:

public abstract class CriticalFinalizerObject { protected CriticalFinalizerObject() { /* there is no code in here */ } // This is the Finalize method ~CriticalFinalizerObject() { /* there is no code in here */ } }

I know that you re thinking that this class doesn t look too exciting, but the CLR treats this class and classes derived from it in a very special manner . In particular, the CLR endows this class with three cool features:

The first time an object of any CriticalFinalizerObject-derived type is constructed, the CLR immediately JIT-compiles all of the Finalize methods in the inheritance hierarchy . Compiling these methods upon object construction guarantees that the native resource will be released when the object is determined to be garbage . Without this eager compiling of the Finalize method, it would be possible to allocate the native resource and use it, but not to get rid of it . Under low memory conditions, the CLR might not be able to find enough memory to compile the Finalize method, which would prevent it from executing, causing the native resource to leak . Or the resource might not be freed if the Finalize method contained code that referred to a type in another assembly, and the CLR failed to locate this other assembly . The CLR calls the Finalize method of CriticalFinalizerObject-derived types after calling the Finalize methods of non CriticalFinalizerObject-derived types . This ensures that managed resource classes that have a Finalize method can access CriticalFinalizerObject-derived objects within their Finalize methods successfully . For example, the FileStream class s Finalize method can flush data from a memory buffer to an underlying disk with confidence that the disk file has not been closed yet . The CLR calls the Finalize method of CriticalFinalizerObject-derived types if an AppDomain is rudely aborted by a host application (such as Microsoft SQL Server or Microsoft ASP .NET) . This also is part of ensuring that the native resource is released even in a case in which a host application no longer trusts the managed code running inside of it .

Now, Microsoft realizes that the most-used native resources are those resources provided by Windows . And Microsoft also realizes that most Windows resources are manipulated with handles (32-bit values on a 32-bit system and 64-bit values on a 64-bit system) . Again,

21

Automatic Memory Management (Garbage Collection)

to make life easier and safer for developers, the System.Runtime.InteropServices namespace includes a class called SafeHandle, which looks like this (I ve added comments in the methods to indicate what they do):

public abstract class SafeHandle : CriticalFinalizerObject, IDisposable { // This is the handle to the native resource protected IntPtr handle; protected SafeHandle(IntPtr invalidHandleValue, Boolean ownsHandle) { this.handle = invalidHandleValue; // If ownsHandle is true, then the native resource is closed when // this SafeHandle-derived object is collected } protected void SetHandle(IntPtr handle) { this.handle = handle; }

// You can explicitly release the resource by calling Dispose or Close public void Dispose() { Dispose(true); } public void Close() { Dispose(true); } // The default Dispose implementation (shown here) is exactly what you want. // Overriding this method is strongly discouraged. protected virtual void Dispose(Boolean disposing) { // The default implementation ignores the disposing argument. // If resource was already released, just return // If ownsHandle is false, return // Set flag indicating that this resource has been released // Call the virtual ReleaseHandle method // Call GC.SuppressFinalize(this) to prevent Finalize from being called // If ReleaseHandle returned true, return // Fire the ReleaseHandleFailed Managed Debugging Assistant (MDA) } // The default Finalize implementation (shown here) is exactly what you want. // Overriding this method is very strongly discouraged. ~SafeHandle() { Dispose(false); } // A derived class overrides this method to implement the code that releases the resource protected abstract Boolean ReleaseHandle(); public void SetHandleAsInvalid() { // Set flag indicating that this resource has been released // Call GC.SuppressFinalize(this) to prevent Finalize from being called } public Boolean IsClosed { get { // Returns flag indicating whether resource was released } }