JAL Computing

// equivalent Dispose pattern
void Dispose(bool disposing) {
   if (disposing) {
      ~T();
   } else {
      !T();
   }
}

public ref class RAII 
{
private:
	int i;
	bool isDeleted;
public:
	RAII() : i(2), isDeleted(false)
	{
		Console::WriteLine(L"Constructor called.");
	}
	~RAII() // maps to Dispose
	{ 
		if (!isDeleted) { // release once only
			// clean up managed resources here.
			Console::WriteLine(L"Releasing managed resources."); 
			this->!RAII(); // clean up unmanaged resources here.
		}
		this->isDeleted= true;
		Console::WriteLine(L"Destructor called.");
		// finalize (!RAII) is automagically suppressed
	};
	!RAII() // maps to finalizer
	{
		if (!isDeleted) 
		{
			// Clean up unmanaged resources here.
			Console::WriteLine(L"Releasing unmanged resources.");
		}
		Console::WriteLine(L"finalizer called.");
	}
	property int I {
		void set(int value) {this->i = value;}
		int get() {return i;}
	}
	// this can be called even after this object has been disposed!
	// ASSERT isDeleted is false
	void SayHello() 
	{
		if (isDeleted) {
			throw gcnew System::InvalidOperationException();
		}
		Console::WriteLine(L"Hello");
	}
	void Close() {
		if (!isDeleted) {
			this->~RAII();
		}
	}
};

RAII r;
r.SayHello();
Console::WriteLine(r.I);

    class Program : IDisposable
    {
        private int i;
        private bool disposed = false;
        public Program()
        {
            i = 2;
            Console.WriteLine("Constructor called.");
        }
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this); // remove this from gc finalizer list
            Console.WriteLine("Dispose called.");
        }
        // call Dispose(true) from Dispose, call Dispose(false) from finalizer
        private void Dispose(bool disposing)
        {
            if (!this.disposed) // dispose once only
            {
                if (disposing) // called from Dispose
                {
                    // Dispose managed resources.
                }
                // Clean up unmanaged resources here.
            }
            disposed = true;
        }
        ~Program() // maps to finalize
        {
            Dispose(false);
        }
        public void SayHello()
        {
            Console.WriteLine("Hello");
        }
        public int I 
        {
            get{return i;}
            set{i = value;}
        }
        static void Main(string[] args)
        {
            using (Program p = new Program())
            {
                p.SayHello();
                Console.WriteLine(p.I);
            }
            Console.ReadLine();
        }
    }

Managed C++ 2005 frees you from the explicit implementation of IDisposable and the using pattern. To implement RAII in Managed C++ 2005, you simply cleanup resources in the destructor and create an object that "appears to go on the stack". The cleanup code will be called when the object "on the stack" goes out of scope. When the destructor is called, the object is removed from the garbage collector finalizer list so that the finalize method is not called. This is equivalent to the C# call to

GC.SuppressFinalize(this);

To a C# caller outside of the assembly, the class simply appears to implement the IDisposable interface as in:

// C# code
using (RAII r = new RAII())
{
    r.SayHello();
    Console.WriteLine(r.I);
}

So, in managed C++ 2005 (C++/cli):

	!MyClass() maps to finalizer which, if called by the garbage collector, runs in a separate thread.
	~MyClass() maps to Dispose which runs in the same thread. The compiler generated Dispose method calls GC.SuppressFinalize(this).
	If you create an object with a destructor on the stack, the destructor will be called when the object goes out of scope.
	When the destructor executes, it removes the object from the finalizer list.
	If you declare a destructor or finalizer, the compiler will generate a Dispose method for you.

If you create an object with a destructor on the heap, the destructor is not called by the garbage collector even when it is unreachable from root. You can still explicitly call the destructor on a managed object on the heap using the delete keyword, but there is nothing stopping the caller from invoking method calls on the "deleted" object. If you explicitly call delete, you may want to immediately set the handle to nullptr, so that the caller cannot invoke a method on a "deleted" object.

// explicit destruction
RAII^ heaped= gcnew RAII();
heaped->SayHello();
Console::WriteLine(heaped->I);
delete heaped;
heaped = nullptr; // after delete, don't use this handle

RAII^ heaped= nullptr;
try 
{
	heaped= gcnew RAII();
	heaped->SayHello();
	Console::WriteLine(heaped->I);
	//throw gcnew Exception();
}
finally 
{
	if (heaped != nullptr) 
	{
		delete heaped;
		heaped= nullptr;
	}
}

// TestDestructor.cpp : main project file.

#include "stdafx.h"

using namespace System;
using namespace System::Diagnostics;

// Demonstrates exception safe behaviour in constructor
public class RAII {
private:
	int *p1,*p2;
	int size;

	// disallow assignment make this private
	// we don't know what to do on partially successful
	// assignment
	RAII& RAII::operator=(const RAII& src) {
		Debug::Assert(true,"assignment operator called");
		return *this; 
	}
public:
	// if the constructor does not finish, then
	// the object never existed
	// no resources in initializer list
	RAII::RAII(int size): p1(0), p2(0) ,size(0) {
		try {
			this->size= size;
			p1= new int[size];
			//throw gcnew Exception();  // RAII object never exists
			p2= new int[size];
			//throw gcnew Exception();  // RAII object never exists
		}
		catch(...) {
			if (p1) {delete p1;}
			if (p2) {delete p2;}
			throw;
		}
		// will not get here on exception
		Console::WriteLine("allocated resources");
	}
	virtual RAII::~RAII() {
		if (p1) {
			delete [] p1;
			p1= 0;
		}
		if (p2) {
			delete [] p2;
			p2= 0;
		}
		Console::WriteLine("released resource");
	}
	RAII::RAII(RAII &src) : p1(0), p2(0) ,size(0){
		try {
			size= src.size;
			p1= new int[src.size];
			p2= new int[src.size];
		}
		catch(...){
			if (p1) {delete p1;}
			if (p2) {delete p2;}
			throw;
		}
		Console::WriteLine("copy");
	}

	int Size() {
		return size;
	}
};

int main(array<System::String ^> ^args)
{
	try {
		RAII r(5);
		Console::WriteLine(r.Size());
	}
	catch(...){
		Console::WriteLine("exception");
	}
    Console::ReadLine();
    return 0;
}

Send mail to [email protected] with questions or comments about this web site. Copyright © 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 © 
Last modified: 08/04/09