Finaliser and Destructor in C++/CLR and their equivalent in C#

原创于 2013-06-07 08:01:25 发布 · 3.1k 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

编码偶记同时被 3 个专栏收录

101 篇文章

订阅专栏

规范与框架

68 篇文章

订阅专栏

Code Scrolls

29 篇文章

订阅专栏

本文深入探讨了C#和C++中资源管理的最佳实践，重点比较了析构函数和最终化器的作用与使用场景。详细解释了如何在两种语言中正确实现资源清理，确保程序的健壮性和效率。

In C# we all know the standard way of finalising an object that potentially contains both managed and unmanaged resources is like

class SomeDisposableEntity : IDisposable
{
    #region Constructors

    ~SomeDisposableEntity()    // finalizer
    {
        Dispose(false);    // invoked from finalizer
    }
    
    #endregion
    
    #region IDisposable members
   
    public void Dispose()
    {
        Dispose(true);    // invoked from disposing method
        GC.SuppressFinalize(this);
    }
   
    #endregion
    
    #region Methods
   
    protected virtual void Dispose(bool disposing)
    {
        if (disposing)
        {
            // free managed resources if any (use flags to prevent duplicated deallocation)
            // ...
        }
        // free native resources if any (use flags to prevent duplicated deallocation)
        // ...
    }
   
    #endregion
    
    #endregion
}

The equivalent C++/CLR looks a bit complicated to C++ programmers, as it introduced the finaliser language feature in addition to the traditional destructor. However to make it simple, we just remember that its finaliser is equivalent to finaliser in C# (with different denotations) and thereby invoked by the garbage collector and C++'s destructor is kind of similar to C#'s Dispose() method responsibility-wise. Therefore note that destructor is normally called before finaliser is called and it's mentioned on MSDN that finalisation of the object is suppressed once the destructor is called, and a typical pattern of writing finalisation code in C++/CLR would be

class SomeDisposableEntity
{
    !SomeDisposableEntity()       // finaliser
    {
        // clean up unmanaged resources if any; make sure not to free twice
        // hence it's similar to C#'s Dispose(false) call
        // ...
    }
    
    ~SomeDisposableEntity()       // destructor
    {
        // clean up managed resources if any; use flags to avoid freeing twice 
        // hence together with the finaliser call below it's similar to C#'s Dispose(true) call
        // ...
        !SomeDisposableEntity();  // destructor always invokes finaliser to clean up unmanaged resources
    }
};

References

[1] Destructors and Finalizers in Visual C++, MSDN, http://msdn.microsoft.com/en-us/library/ms177197(v=vs.80).aspx

[2] Implement IDisposable Correctly, MSDN, http://msdn.microsoft.com/en-us/library/ms244737(v=vs.80).aspx