[转载CSDN]在.NET里的垃圾回收编程 Paul_Ni（原作）

.NET 框架的垃圾回收器管理应用程序的内存分配和释放。每次您使用 new 运算符创建对象时，运行库都从托管堆为该对象分配内存。只要托管堆中有地址空间可用，运行库就会继续为新对象分配空间。但是，内存不是无限大的。最终，垃圾回收器必须执行回收以释放一些内存。垃圾回收器优化引擎根据正在进行的分配情况确定执行回收的最佳时间。当垃圾回收器执行回收时，它检查托管堆中不再被应用程序使用的对象并执行必要的操作来回收它们占用的内存。

开发人员在内存管理方面的背景

根据您开发背景的不同，您在内存管理方面的经验也会有所不同。在某些情况下，您可能需要让您的编程习惯来适应公共语言运行库提供的自动内存管理。

COM 开发人员

COM 开发人员习惯于将实现引用计数作为一个手动的内存管理技术。每次引用一个对象，计数器就递增。如果对对象的引用超出了范围，计数器就递减。当对象的引用计数达到零时，对象被终止并释放其内存。

引用计数方案会引发许多调试错误。如果未能严格地按照引用计数的规则进行操作，对象可能被过早释放或者未引用的对象积存在内存中。循环引用也是常见的问题根源。循环引用出现在子对象引用父对象，而父对象又引用子对象时。这种情况使两个对象都不能被释放或销毁。唯一的解决方案就是让父对象和子对象都遵守一个固定的使用和销毁模式，例如总是先由父对象删除子对象。

当使用托管语言开发应用程序时，运行库的垃圾回收器免除了对引用进行计数的需要，因此也就避免了由这种手动管理内存方案引发的错误。

C++ 开发人员

C++ 开发人员熟悉与手动内存管理相关的任务。在 C++ 中，当您使用 new 运算符为对象分配内存时，您必须使用 delete 运算符释放对象的内存。这可能导致多种错误，例如忘记释放对象、引起内存泄漏或试图访问已被释放的对象的内存。

当使用 C++ 的托管扩展或其他托管语言开发应用程序时，您就不必使用 delete 运算符释放对象了。垃圾回收器在当对象不再被应用程序使用时自动为您完成这些操作。

考虑到手动管理短期对象内存的相关成本，C++ 开发人员可能习惯于避免使用这些对象。对于两次回收间创建的然后又不再使用的托管短期对象，分配和释放内存的成本非常低。在 .NET 框架中，实际上已经对垃圾回收器进行了优化来管理具有较短生存期的对象。当开发托管应用程序时，在短期对象可以简化代码的情况下使用它们是非常合适的。

Visual Basic 开发人员

Visual Basic 开发人员习惯于自动内存管理。您熟悉的编程惯例将应用于您在 .NET 框架中创建的大多数托管对象。但是，当创建或使用封装非托管资源的对象时，您应该特别注意使用 Dispose 方法的推荐设计模式。

.NET 框架支持的托管语言比此处介绍的还要多。不管您使用哪一种托管语言，.NET 框架的垃圾回收器都提供自动内存管理。它为托管对象分配和释放内存，并在必要时执行 Finalize 方法和析构函数来适当地清理非托管资源。自动内存管理通过消除手动内存管理方案引起的常见问题简化了开发。

Finalize 方法和析构函数

对于您的应用程序创建的大多数对象，可以依靠 .NET 框架的垃圾回收器隐式地执行所有必要的内存管理任务。但是，在您创建封装非托管资源的对象时，当您在应用程序中使用完这些非托管资源之后，您必须显式地释放它们。最常见的一类非托管资源就是包装操作系统资源的对象，例如文件、窗口或网络连接。虽然垃圾回收器可以跟踪封装非托管资源的对象的生存期，但它不了解具体如何清理这些资源。对于这些类型的对象，.NET 框架提供 Object.Finalize 方法，它允许对象在垃圾回收器回收该对象使用的内存时适当清理其非托管资源。默认情况下，Finalize 方法不执行任何操作。如果您要让垃圾回收器在回收对象的内存之前对对象执行清理操作，您必须在类中重写 Finalize 方法。当使用 C# 和 C++ 的托管扩展以外的编程语言进行开发时，您可以实现 Finalize 方法。C# 和托管扩展提供析构函数作为编写终止代码的简化机制。析构函数自动生成 Finalize 方法和对基类的 Finalize 方法的调用。在 C# 和托管扩展编程语言中，您必须为终止代码使用析构函数语法。

垃圾回收器使用名为“终止队列”的内部结构跟踪具有 Finalize 方法的对象。每次您的应用程序创建具有 Finalize 方法的对象时，垃圾回收器都在终止队列中放置一个指向该对象的项。托管堆中所有需要在垃圾回收器回收其内存之前调用它们的终止代码的对象都在终止队列中含有项。

实现 Finalize 方法或析构函数对性能可能会有负面影响，因此应避免不必要地使用它们。用 Finalize 方法回收对象使用的内存需要至少两次垃圾回收。当垃圾回收器执行回收时，它只回收没有终结器的不可访问对象的内存。这时，它不能回收具有终结器的不可访问对象。它改为将这些对象的项从终止队列中移除并将它们放置在标为准备终止的对象列表中。该列表中的项指向托管堆中准备被调用其终止代码的对象。一个特殊的运行库线程开始处于活动状态并调用列表中对象的 Finalize 方法，然后将这些项从列表中移除。后来的垃圾回收将确定终止的对象确实是垃圾，因为标为准备终止对象的列表中的项不再指向它们。在后来的垃圾回收中，实际上回收了对象的内存。

清理非托管资源

通过将对象的范围限制为 protected，您可以防止应用程序的用户直接调用对象的 Finalize 方法。除此之外，我们强烈建议您不要直接从应用程序代码中调用非基类的类的 Finalize 方法。为适当处置非托管资源，建议您实现公共的 Dispose 或 Close 方法，这两个方法执行必要的对象清理代码。IDisposable 接口为实现接口的资源类提供 Dispose method。因为 Dispose 方法是公共的，所以应用程序的用户可以直接调用该方法来释放非托管资源占用的内存。如果正确实现了 Dispose 方法，则 Finalize 方法（或者 C# 中的析构函数或 C++ 的托管扩展）就成为避免在没有调用 Dispose 方法的情况下清理资源的一种防护措施。

实现 Dispose 方法  [C#]

类型的 Dispose 方法应该释放它拥有的所有资源。它还应该通过调用其父类型的 Dispose 方法释放其基类型拥有的所有资源。该父类型的 Dispose 方法应该释放它拥有的所有资源并同样也调用其父类型的 Dispose 方法，从而在整个基类型层次结构中传播该模式。要确保始终正确地清理资源，Dispose 方法应该可以被多次安全调用而不引发任何异常。

Dispose 方法应该为它处置的对象调用 GC.SuppressFinalize 方法。如果对象当前在终止队列中，GC.SuppressFinalize 防止其 Finalize 方法被调用。请记住，执行 Finalize 方法会大大减损性能。如果您的 Dispose 方法已经完成了清理对象的工作，那么垃圾回收器就不必调用对象的 Finalize 方法了。

下面的代码示例旨在阐释如何为封装了非托管资源的类实现 Dispose 方法的一种可能的设计模式。因为该模式是在整个 .NET 框架中实现的，所以您可能会发现它十分便于使用。但是，这不是 Dispose 方法唯一可能的实现。

资源类通常是从复杂的本机类或 API 派生的，而且必须进行相应的自定义。使用这一代码模式作为创建资源类的一个起始点，并根据封装的资源提供必要的自定义。不能编译该示例，也不能将其直接用于应用程序。

在此示例中，基类 BaseResource 实现可由类的用户调用的公共 Dispose 方法。而该方法又调用 virtual Dispose(bool disposing) 方法（Visual Basic 中的虚 Dispose（作为布尔值处置））。根据调用方的标识传递 true 或 false。以虚 Dispose 方法为对象执行适当的清理代码。

Dispose(bool disposing) 以两种截然不同的方案执行。如果处置结果为 true，则该方法已由用户的代码直接调用或间接调用，并且可处置托管资源和非托管资源。如果处置结果为 false，则该方法已由运行库从终结器内部调用，并且只能处置非托管资源。因为终结器不会以任意特定的顺序执行，所以当对象正在执行其终止代码时，不应引用其他对象。如果正在执行的终结器引用了另一个已经终止的对象，则该正在执行的终结器将失败。

基类提供的 Finalize 方法或析构函数在未能调用 Dispose 的情况下充当防护措施。Finalize 方法调用带有参数的 Dispose 方法，同时传递 false。不应在 Finalize 方法内重新创建 Dispose 清理代码。调用 Dispose(false) 可以优化代码的可读性和可维护性。

类 MyResourceWrapper 阐释如何用 Dispose 从实现资源管理的类派生。MyResourceWrapper 重写 virtual Dispose(bool disposing) 方法并为其创建的托管和非托管资源提供清理代码。MyResourceWrapper 还对其基类 BaseResource 调用 Dispose 以确保其基类能够适当地进行清理。请注意，派生类 MyResourceWrapper 没有不带参数的 Finalize 方法或 Dispose 方法，因为这两个方法从基类 BaseResource 继承它们。

[Visual Basic]

' Design pattern for the base class.

' By implementing IDisposable, you are announcing that instances

' of this type allocate scarce resources.

Public Class BaseResource

   Implements IDisposable

   ' Pointer to an external unmanaged resource.

   Private handle As IntPtr 

   ' Other managed resource this class uses.

   Private Components As Component

   ' Track whether Dispose has been called.

   Private disposed As Boolean = False

   ' Constructor for the BaseResource Object.

   Public Sub New()

      ' Insert appropriate constructor code here.

   End Sub

   ' Implement Idisposable.

   ' Do not make this method Overridable.

   ' A derived class should not be able to override this method.

   Overloads Public Sub Dispose()Implements IDisposable.Dispose

      Dispose(true)

      ' Take yourself off of the finalization queue

      ' to prevent finalization code for this object

      ' from executing a second time.

      GC.SuppressFinalize(Me) 

   End Sub

' Dispose(disposing As Boolean) executes in two distinct scenarios.

' If disposing is true, the method has been called directly 

' or indirectly by a user's code. Managed and unmanaged resources 

' can be disposed.

' If disposing equals false, the method has been called by the runtime

' from inside the finalizer and you should not reference other    

' objects. Only unmanaged resources can be disposed.

Overloads Protected Overridable Sub Dispose(disposing As Boolean)

   ' Check to see if Dispose has already been called.

   If Not (Me.disposed) Then

      ' If disposing equals true, dispose all managed 

      ' and unmanaged resources.

      If (disposing) Then

         ' Dispose managed resources.

         Components.Dispose()

      End If

      ' Release unmanaged resources. If disposing is false,

      ' only the following code is executed.      

      CloseHandle(handle)

      handle = IntPtr.Zero

      ' Note that this is not thread safe.

      ' Another thread could start disposing the object

      ' after the managed resources are disposed,

      ' but before the disposed flag is set to true.

   End If

   Me.disposed = true

End Sub

   ' This Finalize method will run only if the 

   ' Dispose method does not get called.

   ' By default, methods are NotOverridable. 

   ' This prevents a derived class from overriding this method.

   Overrides Protected Sub Finalize()

         ' Do not re-create Dispose clean-up code here.

         ' Calling Dispose(false) is optimal in terms of

         ' readability and maintainability.

         Dispose(false)

   End Sub

   ' Allow your Dispose method to be called multiple times,

   ' but throw an exception if the object has been disposed.

   ' Whenever you do something with this class, 

   ' check to see if it has been disposed.

   Public Sub DoSomething()

      If Me.disposed Then

         Throw New ObjectDisposedException()

      End if

   End Sub

End Class

' Design pattern for a derived class.

' Note that this derived class inherently implements the 

' IDisposable interface because it is implemented in the base class.

Public Class MyResourceWrapper

   Inherits BaseResource

   ' A managed resource that you add in this derived class.

   private addedManaged As ManagedResource

   ' A native unmanaged resource that you add in this derived class.

   private addedNative As NativeResource

   ' Track whether Dispose has been called.

   Private disposed As Boolean = False

   ' Constructor for the MyResourceWrapper Object.

   Public Sub New()      

      MyBase.New()

      ' Insert appropriate constructor code here for the

      ' added resources.

   End Sub

   Protected Overloads Overrides Sub Dispose(disposing As Boolean)

      If Not (Me.disposed) Then

         Try

            If disposing Then

              ' Release the managed resources you added in

              ' this derived class here.

              addedManaged.Dispose()

            End If

            ' Release the native unmanaged resources you added

            ' in this derived class here.

            CloseHandle(addedNative)

            Me.disposed = true

         Finally

            ' Call Dispose on your base class.

            MyBase.Dispose(disposing)

         End Try

      End If

   End Sub

End Class

' This derived class does not have a Finalize method

' or a Dispose method without parameters because it 

' inherits them from the base class.

[C#]

// Design pattern for the base class.

// By implementing IDisposable, you are announcing that instances

// of this type allocate scarce resources.

public class BaseResource: IDisposable

{

   // Pointer to an external unmanaged resource.

   private IntPtr handle;

   // Other managed resource this class uses.

   private Component Components;

   // Track whether Dispose has been called.

   private bool disposed = false;

   // Constructor for the BaseResource Object.

   public BaseResource()

   {

      // Insert appropriate constructor code here.

   }

   // Implement Idisposable.

   // Do not make this method virtual.

   // A derived class should not be able to override this method.

   public void Dispose()

   {

      Dispose(true);

      // Take yourself off of the Finalization queue 

      // to prevent finalization code for this object

      // from executing a second time.

      GC.SuppressFinalize(this);

   }

   // Dispose(bool disposing) executes in two distinct scenarios.

   // If disposing equals true, the method has been called directly

   // or indirectly by a user's code. Managed and unmanaged resources

   // can be disposed.

   // If disposing equals false, the method has been called by the 

   // runtime from inside the finalizer and you should not reference 

   // other objects. Only unmanaged resources can be disposed.

   protected virtual void Dispose(bool disposing)

   {

      // Check to see if Dispose has already been called.

      if(!this.disposed)

      {

         // If disposing equals true, dispose all managed 

         // and unmanaged resources.

         if(disposing)

         {

            // Dispose managed resources.

            Components.Dispose();

         }

         // Release unmanaged resources. If disposing is false, 

         // only the following code is executed.

         CloseHandle(handle);

         handle = IntPtr.Zero;

         // Note that this is not thread safe.

         // Another thread could start disposing the object

         // after the managed resources are disposed,

         // but before the disposed flag is set to true.

      }

      disposed = true;         

   }

   // Use C# destructor syntax for finalization code.

   // This destructor will run only if the Dispose method 

   // does not get called.

   // It gives your base class the opportunity to finalize.

   // Do not provide destructors in types derived from this class.

   ~BaseResource()      

   {

      // Do not re-create Dispose clean-up code here.

      // Calling Dispose(false)is optimal in terms of

      // readability and maintainability.

      Dispose(false);

   }

   // Allow your Dispose method to be called multiple times,

   // but throw an exception if the object has been disposed.

   // Whenever you do something with this class, 

   // check to see if it has been disposed.

   public void DoSomething()

   {

      if(this.disposed)

      {

         throw new ObjectDisposedException();

      }

   }

}

// Design pattern for a derived class.

// Note that this derived class inherently implements the 

// IDisposable interface because it is implemented in the base class.

public class MyResourceWrapper: BaseResource

{

   // A managed resource that you add in this derived class.

   private ManagedResource addedManaged;

   // A native unmanaged resource that you add in this derived class.

   private NativeResource addedNative;

   private bool disposed = false;

  // Constructor for this object.

   public MyResourceWrapper()

   {

      // Insert appropriate constructor code here.

   }

   protected override void Dispose(bool disposing)

   {

      if(!this.disposed)

      {

         try

         {

            if(disposing)

            {

               // Release the managed resources you added in

               // this derived class here.

               addedManaged.Dispose();         

            }

            // Release the native unmanaged resources you added

            // in this derived class here.

            CloseHandle(addedNative);

            this.disposed = true;

         }

         finally

         {

            // Call Dispose on your base class.

            base.Dispose(disposing);

         }

      }

   }

}

// This derived class does not have a Finalize method

// or a Dispose method with parameters because it inherits 

// them from the base class.

实现 Close 方法

对于类型来说，若调用 Close 方法比调用 Dispose 方法更简易，则可以向基类型添加一个公共 Close 方法。 Close 方法又调用没有参数的 Dispose 方法，该方法可以执行正确的清理操作。下面的代码示例阐释了 Close 方法。

[Visual Basic]

' Do not make this method Overridable.

' A derived class should not be allowed

' to override this method.

Public Sub Close()

   ' Calls the Dispose method without parameters.

   Dispose()

End Sub

[C#]

// Do not make this method virtual.

// A derived class should not be allowed

// to override this method.

public void Close()

{

   // Calls the Dispose method without parameters.

   Dispose();

}

重写 Finalize 方法

Finalize 方法在未能调用 Dispose 方法的情况下充当防护措施来清理资源。您应该只实现 Finalize 方法来清理非托管资源。您不应该对托管对象实现 Finalize 方法，因为垃圾回收器会自动清理托管资源。默认情况下，Object.Finalize 方法不进行任何操作。如果要让垃圾回收器在回收对象的内存之前对对象执行清理操作，您必须在类中重写此方法。

注意 在 C# 或 C++ 的托管扩展编程语言中，您不能重写 Finalize 方法。您必须使用这些语言提供的析构函数语法作为编写终止代码的机制。

Object.Finalize 方法的范围是受保护的。当在类中重写该方法时，您应该保持这个有限的范围。通过保护 Finalize 方法，您可以防止应用程序的用户直接调用对象的 Finalize 方法。

对象的 Finalize 方法应该释放该对象保留的所有资源。它还应该调用该对象基类的 Finalize 方法。对象的 Finalize 方法不应对任何非其基类的对象调用方法。这是因为被调用的其他对象可能和调用对象在同一时间被回收，例如公共语言运行库关闭这种情况。

如果您允许任何异常避开 Finalize 方法，系统将认为方法返回，并继续调用其他对象的 Finalize 方法。

使用 C# 和 C++ 托管扩展的析构函数语法

在 C# 或 C++ 的托管扩展编程语言中，您不能调用或重写 Object.Finalize 方法。C# 和托管扩展提供析构函数作为编写终止代码的机制。在 C# 和托管扩展中，您必须使用析构函数语法来执行清理操作。因为该语法隐式地为对象基类调用 Finalize 方法，所以十分方便易用。这保证了对当前类从其导出的所有级别的析构函数都调用了 Finalize。

下面的代码示例是为析构函数编写的。

~MyClass()

{

   // Perform some cleanup operations here.

}

该代码隐式翻译为下面的代码。

protected override void Finalize()

{

   try

   {

      // Perform some cleanup operations here.

   }

   finally

   {

      base.Finalize();

   }

}

注意 虽然它们看上去相似，但 C# 和托管扩展析构函数与非托管 C++ 析构函数具有不同的语义。托管代码不支持任何与 C++ 析构函数语义相似的语义。

使用封装资源的对象

当编写使用封装资源的对象的代码时，您应该确保当使用完该对象时将调用该对象的 Dispose 方法。您可以使用 C# 的 using 语句或在其他托管语言中实现 try/finally 块来完成此操作。

C# 的 Using 语句

C# 编程语言的 using 语句通过简化您必须编写以创建和清理对象的代码，更为自动地对 Dispose 方法进行调用。using 语句获得一个或多个资源，执行您指定的语句，然后处置对象。请注意，using 语句只用于生存期不超过在其中构建对象的方法的对象。下面的代码示例创建并清理 ResourceWrapper 类的实例，如实现 Dispose 方法的 C# 示例所示。

class myApp

{

   public static void Main()

   {

      using (ResourceWrapper r1 = new ResourceWrapper())

      {

         // Do something with the object.

         r1.DoSomething();

      }

   }

}

以上集成有 using 语句的代码与下面的代码等效。

class myApp

{

   public static void Main()

   {

      ResourceWrapper r1 = new ResourceWrapper();

      try

      {

         // Do something with the object.

         r1.DoSomething();

      }

      finally

      {

         // Check for a null resource.

         if (r1 != null)

         // Call the object's Dispose method.

         r1.Dispose();

      }

   }

}

C# 的 using 语句允许您在单个语句中获取多个资源，该语句在内部同嵌套的 using 语句是等效的。有关更多信息和代码示例，请参阅 C# 语言参考中的 8.13 using 语句一节。

Try/Finally 块

当您在 C# 以外的语言中编写使用封装资源的对象的托管代码时，请使用 try/finally 块来确保调用了对象的 Dispose 方法。下面的代码示例创建并清理 Resource 类的实例，如实现 Dispose 方法的 Visual Basic 示例所示。

class myApp

   Public Shared Sub Main()

      Resource r1 = new Resource()

      Try

         ' Do something with the object.

         r1.DoSomething()

      Finally

         ' Check for a null resource.

         If Not (r1 is Nothing) Then

            ' Call the object's Dispose method.

            r1.Dispose()

         End If

      End Try

   End Sub

End Class

强制垃圾回收

垃圾回收 GC 类提供 GC.Collect 方法，您可以使用该方法让应用程序在一定程度上直接控制垃圾回收器。通常情况下，您应该避免调用任何回收方法，让垃圾回收器独立运行。在大多数情况下，垃圾回收器在确定执行回收的最佳时机方面更有优势。但是，在某些不常发生的情况下，强制回收可以提高应用程序的性能。当应用程序代码中某个确定的点上使用的内存量大量减少时，在这种情况下使用 GC.Collect 方法可能比较合适。例如，应用程序可能使用引用大量非托管资源的文档。当您的应用程序关闭该文档时，您完全知道已经不再需要文档曾使用的资源了。出于性能的原因，一次全部释放这些资源很有意义。有关更多信息，请参阅 GC.Collect 方法。

在垃圾回收器执行回收之前，它会挂起当前正在执行的所有线程。如果不必要地多次调用 GC.Collect，这可能会造成性能问题。您还应该注意不要将调用 GC.Collect 的代码放置在程序中用户可以经常调用的点上。这可能会削弱垃圾回收器中优化引擎的作用，而垃圾回收器可以确定运行垃圾回收的最佳时间。

总结

    上面是.NET框架中垃圾回收和处理方面的一些概念和少许示例，给大家参考一下。有任何建议请MAIL我 paulni@citiz.net。