C＃/ CLI：如果在其中使用Dispose（），则不会调用析构函数

Question

I have a C++/CLI class named "CTransferManaged" with implemented finalizer and destructor:

CTransferManaged::~CTransferManaged()
{
    this->!CTransferManaged();
}
CTransferManaged::!CTransferManaged()
{
    //Clean up resources... 
}

This class is wrapped with a C# class named "CTransfer" containig an object m_transfer of type CTransferManaged.

If the destructor of this class only clears the reference to the object m_transfer I can see that the destructor is called (breakpoint is hit):

~CTransfer()
{
    m_transfer = null; //breakpoint on this line
}

If I call the Dispose() function of the m_transfer object without changing anything else, the destructor is not called anymore (breakpoint no more hit). Any guesses why?

~CTransfer()
{
    m_transfer.Dispose(); //breakpoint on this line
    m_transfer = null;
}

I would like to call Dispose() manually since I found out that the resources of the C++/CLI object (m_transfer) are not cleaned up properly if I don't call Dispose manually. At the moment I don't know exactly why.

Why is the destructor of CTransfer (C# class) no more called as soon as it calls CTransferManaged::Dispose() (C++/CLI)?

Answer 1

C# destructor only get called by the garbage collector and you can not call it directly.

Dispose which is part of IDisposalbe interface should be only called manually and it will not fire the destructor.

Instead of relying on destructor try to implement iDisposabe and called the Dispose method directly and put your code there.

If the Resource class contains embedded objects that should be disposed, this pattern is needed with C#:

// C#
public class Resource : IDisposable
{
   private EmbeddedResource embedded;

   public Resource()
   {
      Console.WriteLine("allocating resource");
      embedded = new EmbeddedResource();
   }

   ~Resource()
   {
      Dispose(false);
   }

   protected virtual void Dispose(bool disposing)
   {
      Console.WriteLine("release resource");
      if (disposing)
      {
         embedded.Dispose();
      }
   }

   public void Dispose()
   {
      Dispose(true);
   }
}

Answer 2

The typical pattern for Disposing and Finalizing is such that when you call Dispose, the finalizer should be suppressed. Dispose is intended to clear resources as soon as it is executed, whereas the finalizer is meant to clear resources whenever the garbage collector collects the class... Both are intended to do the same thing (release unmanaged resources), and so if you call Dispose, calling the finalizer would then be redundant and unnecessary, and would also cause the object to live longer than it needs to since it would first be placed on the Finalizer queue before being collected and destructed. This causes poor memory management on highly accessed applications which create and dispose many objects. Therefore, most Dispose methods in C# will call:

GC.SuppressFinalize(this);

Which tells the Garbage collector to not do the finalizer. This pattern is widely used and is likely utilized in your unmanaged class as well. This is probably why the Dispose call eliminates the destructor.