GC.SuppressFinalize(Object) Metoda

Definice

Požaduje, aby modul CLR (Common Language Runtime) nevolal finalizační metodu pro zadaný objekt.Requests that the common language runtime not call the finalizer for the specified object.

public:
 static void SuppressFinalize(System::Object ^ obj);
public static void SuppressFinalize (object obj);
static member SuppressFinalize : obj -> unit
Public Shared Sub SuppressFinalize (obj As Object)

Parametry

obj
Object

Objekt, jehož finalizační metoda se nesmí provést.The object whose finalizer must not be executed.

Výjimky

obj je null.obj is null.

Příklady

Následující příklad ukazuje, jak použít SuppressFinalize metodu ve třídě prostředků, abyste zabránili volání redundantního uvolňování paměti.The following example demonstrates how to use the SuppressFinalize method in a resource class to prevent a redundant garbage collection from being called. V příkladu se používá vzor Dispose pro uvolnění spravovaných prostředků (tj. objektů, které implementují IDisposable ) a nespravovaných prostředků.The example uses the dispose pattern to free both managed resources (that is, objects that implement IDisposable) and unmanaged resources.

using System;
using System.ComponentModel;
using System.Runtime.InteropServices;

public class ConsoleMonitor : IDisposable
{
   const int STD_INPUT_HANDLE = -10;
   const int STD_OUTPUT_HANDLE = -11;
   const int STD_ERROR_HANDLE = -12;

   [DllImport("kernel32.dll", SetLastError = true)]
   static extern IntPtr GetStdHandle(int nStdHandle);

   [DllImport("kernel32.dll", SetLastError = true)]
   static extern bool WriteConsole(IntPtr hConsoleOutput, string lpBuffer,
          uint nNumberOfCharsToWrite, out uint lpNumberOfCharsWritten,
          IntPtr lpReserved);

   [DllImport("kernel32.dll", SetLastError = true)]
   static extern bool CloseHandle(IntPtr handle);

   private bool disposed = false;
   private IntPtr handle;
   private Component component;

   public ConsoleMonitor()
   {
      handle = GetStdHandle(STD_OUTPUT_HANDLE);
      if (handle == IntPtr.Zero)
         throw new InvalidOperationException("A console handle is not available.");

      component = new Component();

      string output = "The ConsoleMonitor class constructor.\n";
      uint written = 0;
      WriteConsole(handle, output, (uint) output.Length, out written, IntPtr.Zero);
   }

   // The destructor calls Object.Finalize.
   ~ConsoleMonitor()
   {
      if (handle != IntPtr.Zero) {
         string output = "The ConsoleMonitor finalizer.\n";
         uint written = 0;
         WriteConsole(handle, output, (uint) output.Length, out written, IntPtr.Zero);
      }
      else {
         Console.Error.WriteLine("Object finalization.");
      }
      // Call Dispose with disposing = false.
      Dispose(false);
   }

   public void Write()
   {
      string output = "The Write method.\n";
      uint written = 0;
      WriteConsole(handle, output, (uint) output.Length, out written, IntPtr.Zero);
   }

   public void Dispose()
   {
      string output = "The Dispose method.\n";
      uint written = 0;
      WriteConsole(handle, output, (uint) output.Length, out written, IntPtr.Zero);

      Dispose(true);
      GC.SuppressFinalize(this);
   }

   private void Dispose(bool disposing)
   {
      string output = String.Format("The Dispose({0}) method.\n", disposing);
      uint written = 0;
      WriteConsole(handle, output, (uint) output.Length, out written, IntPtr.Zero);

      // Execute if resources have not already been disposed.
      if (! disposed) {
         // If the call is from Dispose, free managed resources.
         if (disposing) {
            Console.Error.WriteLine("Disposing of managed resources.");
            if (component != null)
               component.Dispose();
         }
         // Free unmanaged resources.
         output = "Disposing of unmanaged resources.";
         WriteConsole(handle, output, (uint) output.Length, out written, IntPtr.Zero);

         if (handle != IntPtr.Zero) {
            if (! CloseHandle(handle))
               Console.Error.WriteLine("Handle cannot be closed.");
         }
      }
      disposed = true;
   }
}

public class Example
{
   public static void Main()
   {
      Console.WriteLine("ConsoleMonitor instance....");
      ConsoleMonitor monitor = new ConsoleMonitor();
      monitor.Write();
      monitor.Dispose();
   }
}
// If the monitor.Dispose method is not called, the example displays the following output:
//       ConsoleMonitor instance....
//       The ConsoleMonitor class constructor.
//       The Write method.
//       The ConsoleMonitor finalizer.
//       The Dispose(False) method.
//       Disposing of unmanaged resources.
//
// If the monitor.Dispose method is called, the example displays the following output:
//       ConsoleMonitor instance....
//       The ConsoleMonitor class constructor.
//       The Write method.
//       The Dispose method.
//       The Dispose(True) method.
//       Disposing of managed resources.
//       Disposing of unmanaged resources.
Imports System.ComponentModel
Imports System.Runtime.InteropServices

Public Class ConsoleMonitor
   Private Const STD_INPUT_HANDLE As Integer = -10
   Private Const STD_OUTPUT_HANDLE As Integer = -11
   Private Const STD_ERROR_HANDLE As Integer = -12

   Private Declare Function GetStdHandle Lib "kernel32" _
                            (nStdHandle As Integer) As IntPtr

   Private Declare Function WriteConsole Lib "kernel32" _
                            Alias "WriteConsoleA" _
                            (hConsoleOutput As IntPtr, lpBuffer As String,
                            nNumberOfCharsToWrite As UInteger, 
                            ByRef lpNumberOfCharsWritten As UInteger,
                            lpReserved As IntPtr) As Boolean 

   Private Declare Function CloseHandle Lib "kernel32" _ 
                           (handle As IntPtr) As Boolean
                    
   Private disposed As Boolean = False
   Private handle As IntPtr
   Private component As Component
   
   Public Sub New()
      handle = GetStdHandle(STD_OUTPUT_HANDLE)
      If handle = IntPtr.Zero Then
         Throw New InvalidOperationException("A console handle is not available.")
      End If
      
      component = new Component()
      
      Dim output As String = "The ConsoleMonitor class constructor." + vbCrLf
      Dim written As UInteger = 0
      WriteConsole(handle, output, CUInt(output.Length), written, IntPtr.Zero)
   End Sub

   Protected Overrides Sub Finalize()
      If handle <> IntPtr.Zero Then
         Dim output As String = "The ConsoleMonitor finalizer." + vbCrLf
         Dim written As UInteger = 0
         WriteConsole(handle, output, CUInt(output.Length), written, IntPtr.Zero)
      Else     
         Console.Error.WriteLine("Object finalization.")
      End If
      ' Call Dispose with disposing = false.
      Dispose(false)
   End Sub

   Public Sub Write()
      Dim output As String = "The Write method." + vbCrLf
      Dim written As UInteger = 0
      WriteConsole(handle, output, CUInt(output.Length), written, IntPtr.Zero)
   End Sub

   Public Sub Dispose()
      Dim output As String =  "The Dispose method." + vbCrLf
      Dim written As UInteger = 0
      WriteConsole(handle, output, CUInt(output.Length), written, IntPtr.Zero)

      Dispose(True)
      GC.SuppressFinalize(Me) 
   End Sub

   Private Sub Dispose(disposing As Boolean)
      Dim output As String =  String.Format("The Dispose({0}) method.{1}", 
                                            disposing, vbCrLf)
      Dim written As UInteger = 0
      WriteConsole(handle, output, CUInt(output.Length), written, IntPtr.Zero)

      ' Execute if resources have not already been disposed.
      If Not disposed Then
         ' If the call is from Dispose, free managed resources.
         If disposing Then
            Console.Error.WriteLine("Disposing of managed resources.")
            If component IsNot Nothing Then component.Dispose()
         End If
         ' Free unmanaged resources.
         output = "Disposing of unmanaged resources."
         WriteConsole(handle, output, CUInt(output.Length), written, IntPtr.Zero)
         
         If handle <> IntPtr.Zero Then
            If Not CloseHandle(handle) Then
               Console.Error.WriteLine("Handle cannot be closed.")
            End If    
         End If   
      End If
      disposed = True
   End Sub
End Class

Module Example
   Public Sub Main()
      Console.WriteLine("ConsoleMonitor instance....")
      Dim monitor As New ConsoleMonitor
      monitor.Write()
      monitor.Dispose()
   End Sub
End Module
' If the monitor.Dispose method is not called, the example displays the following output:
'       ConsoleMonitor instance....
'       The ConsoleMonitor class constructor.
'       The Write method.
'       The ConsoleMonitor finalizer.
'       The Dispose(False) method.
'       Disposing of unmanaged resources.
'       
' If the monitor.Dispose method is called, the example displays the following output:
'       ConsoleMonitor instance....
'       The ConsoleMonitor class constructor.
'       The Write method.
'       The Dispose method.
'       The Dispose(True) method.
'       Disposing of managed resources.
'       Disposing of unmanaged resources.

Poznámky

Tato metoda nastavuje bit v záhlaví objektu obj , který modul runtime kontroluje při volání finalizační metody.This method sets a bit in the object header of obj, which the runtime checks when calling finalizers. Finalizační metoda, která je reprezentovaná Object.Finalize metodou, se používá k uvolnění nespravovaných prostředků před uvolněním paměti objektu.A finalizer, which is represented by the Object.Finalize method, is used to release unmanaged resources before an object is garbage-collected. Pokud nemá obj finalizační metodu nebo GC již oznámilo, že vlákno finalizační metody spustí finalizační metodu, volání SuppressFinalize metody nemá žádný vliv.If obj does not have a finalizer or the GC has already signaled the finalizer thread to run the finalizer, the call to the SuppressFinalize method has no effect.

Objekty, které implementují IDisposable rozhraní, mohou volat tuto metodu z implementace objektu, IDisposable.Dispose aby zabránily uvolňování paměti v volání Object.Finalize objektu, který to nevyžaduje.Objects that implement the IDisposable interface can call this method from the object's IDisposable.Dispose implementation to prevent the garbage collector from calling Object.Finalize on an object that does not require it. Obvykle je toto provedeno, aby finalizační metoda zabránila uvolňování nespravovaných prostředků, které již byly uvolněny IDisposable.Dispose implementací.Typically, this is done to prevent the finalizer from releasing unmanaged resources that have already been freed by the IDisposable.Dispose implementation.

Platí pro

Viz také