Suppose you build a class that needs a temporary directory for its
operations:

class MyClass
{
   private string m_tempDir;
   public MyClass()
   {
       m_tempDir = @"C:\" + System.Guid.NewGuid().ToString();
       System.IO.Directory.CreateDirectory( m_tempDir );
   }
}

When an object of this type is instantiated, a temporary directory will be
created.  When the instance is garbage collected, I would like the directory
to disappear.  I'ts very tempting to add a finalizer to the class:

~MyClass()
{
   System.IO.Directory.Delete( m_tempDir );
}

***BUT*** as I understood, the order in which managed objects is
inpredictable so m_tempDir could be collected before the MyClass finalizer
code is executed.  This makes it illegal to access m_tempDir in the
finalizer.

So the question is: which pattern can be used to guarantee that the
temporary directory will be deleted when a MyClass instance is collected?

I don't want to rely on the client code to call some dispose method, I want
the class itself to make sure it cleans up the temp directory.  I also don't
like the idea of allocating some unmanaged memory to store the filename: in
my opinion, this does not result in .Net code as it is meant to be
written...

More generic: which pattern can be used if a finalizer needs to carry out
some clean-up actions (delete a file, stop a thread, stop sponsoring a
remote object,... ) that need access to other managed objects to which the
finalizing object holds the only reference?