GC.WaitForPendingFinalizers Méthode

Définition

Espace de noms:

System

Assemblys:

netstandard.dll, System.Runtime.dll

Source:

GC.CoreCLR.cs

Suspend le thread actif jusqu'à ce que le thread traitant la file d'attente des finaliseurs ait vidé cette file d'attente.

C#

public static void WaitForPendingFinalizers();

Exemples

L’exemple suivant montre comment utiliser la WaitForPendingFinalizers méthode pour suspendre le thread actuel jusqu’à la finalisation de tous les objets collectés.

C#

using System;

namespace WaitForPendingFinalizersExample
{
   class MyWaitForPendingFinalizersClass
   {
    // You can increase this number to fill up more memory.
    const int numMfos = 1000;
    // You can increase this number to cause more
    // post-finalization work to be done.
    const int maxIterations = 100;

    static void Main(string[] args)
    {
       MyFinalizeObject mfo = null;

       // Create and release a large number of objects
       // that require finalization.
       for(int j = 0; j < numMfos; j++)
       {
          mfo = new MyFinalizeObject();
       }

       //Release the last object created in the loop.
       mfo = null;

       //Force garbage collection.
       GC.Collect();

       // Wait for all finalizers to complete before continuing.
       // Without this call to GC.WaitForPendingFinalizers,
       // the worker loop below might execute at the same time
       // as the finalizers.
       // With this call, the worker loop executes only after
       // all finalizers have been called.
       GC.WaitForPendingFinalizers();

       // Worker loop to perform post-finalization code.
       for(int i = 0; i < maxIterations; i++)
       {
          Console.WriteLine("Doing some post-finalize work");
       }
    }
   }

   class MyFinalizeObject
   {
    // Make this number very large to cause the finalizer to
    // do more work.
    private const int maxIterations = 10000;

    ~MyFinalizeObject()
    {
       Console.WriteLine("Finalizing a MyFinalizeObject");
            
       // Do some work.
       for(int i = 0; i < maxIterations; i++)
       {
          // This method performs no operation on i, but prevents
          // the JIT compiler from optimizing away the code inside
          // the loop.
          GC.KeepAlive(i);
       }
        }
    }
}

Remarques

Lorsque le récupérateur de mémoire trouve des objets qui peuvent être récupérés, il vérifie chaque objet pour déterminer les exigences de finalisation de l’objet. Si un objet implémente un finaliseur et n’a pas désactivé la finalisation en appelant SuppressFinalize, l’objet est placé dans une liste d’objets marqués comme prêts pour la finalisation. Le récupérateur de mémoire appelle les Finalize méthodes pour les objets de cette liste et supprime les entrées de la liste. Cette méthode se bloque jusqu’à ce que tous les finaliseurs aient été exécutés jusqu’à la fin.

Le thread sur lequel les finaliseurs sont exécutés n’est pas spécifié, il n’est donc pas garanti que cette méthode se termine. Toutefois, ce thread peut être interrompu par un autre thread pendant que la WaitForPendingFinalizers méthode est en cours. Par exemple, vous pouvez démarrer un autre thread qui attend un certain temps, puis l’interrompre si ce thread est toujours suspendu.

S’applique à