GC.SuppressFinalize(Object) Méthode

Définition

Espace de noms:

System

Assemblys:

netstandard.dll, System.Runtime.dll

Source:

GC.CoreCLR.cs

Demande que le Common Language Runtime n'appelle pas le finaliseur pour l'objet spécifié.

C#

public static void SuppressFinalize(object obj);

Paramètres

obj

Object

Objet dont le finaliseur ne doit pas être exécuté.

Exceptions

ArgumentNullException

obj a la valeur null.

Exemples

L’exemple suivant montre comment utiliser la SuppressFinalize méthode dans une classe de ressources pour empêcher l’appel d’un garbage collection redondant. L’exemple utilise le modèle de suppression pour libérer à la fois les ressources managées (c’est-à-dire les objets qui implémentent IDisposable) et les ressources non managées.

C#

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 finalizer represents Object.Finalize override.
   ~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.");
      }
      Dispose(disposing: 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(disposing: 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.

Remarques

Cette méthode définit un bit dans l’en-tête d’objet de obj, que le runtime vérifie lors de l’appel de finaliseurs. Un finaliseur, qui est représenté par la Object.Finalize méthode , est utilisé pour libérer des ressources non managées avant qu’un objet ne soit récupéré par la mémoire. Si obj n’a pas de finaliseur ou si le GC a déjà signalé au thread du finaliseur pour exécuter le finaliseur, l’appel à la SuppressFinalize méthode n’a aucun effet.

Les objets qui implémentent l’interface IDisposable peuvent appeler cette méthode à partir de l’implémentation de IDisposable.Dispose l’objet pour empêcher le récupérateur de mémoire d’appeler Object.Finalize sur un objet qui n’en a pas besoin. En règle générale, cette opération est effectuée pour empêcher le finaliseur de libérer des ressources non managées qui ont déjà été libérées par l’implémentation IDisposable.Dispose .

S’applique à

Voir aussi

• ReRegisterForFinalize(Object)
• Finalize()
• Dispose, modèle