GC GC GC GC Class

Définition

Contrôle le garbage collector du système, un service qui récupère automatiquement la mémoire inutilisée.Controls the system garbage collector, a service that automatically reclaims unused memory.

public ref class GC abstract sealed
public static class GC
type GC = class
Public Class GC
Héritage

Exemples

L’exemple suivant utilise plusieurs méthodes GC pour obtenir la génération et les informations de mémoire sur un bloc d’objets inutilisés et l’imprimer à la console.The following example uses several GC methods to get generation and memory information about a block of unused objects and print it to the console. Les objets inutilisés sont ensuite recueillies et les totaux de mémoire sont affichées.The unused objects are then collected, and the resulting memory totals are displayed.

using namespace System;
const long maxGarbage = 1000;
ref class MyGCCollectClass
{
public:
   void MakeSomeGarbage()
   {
      Version^ vt;
      for ( int i = 0; i < maxGarbage; i++ )
      {
         
         // Create objects and release them to fill up memory
         // with unused objects.
         vt = gcnew Version;

      }
   }

};

int main()
{
   MyGCCollectClass^ myGCCol = gcnew MyGCCollectClass;
   
   // Determine the maximum number of generations the system
   // garbage collector currently supports.
   Console::WriteLine( "The highest generation is {0}", GC::MaxGeneration );
   myGCCol->MakeSomeGarbage();
   
   // Determine which generation myGCCol object is stored in.
   Console::WriteLine( "Generation: {0}", GC::GetGeneration( myGCCol ) );
   
   // Determine the best available approximation of the number
   // of bytes currently allocated in managed memory.
   Console::WriteLine( "Total Memory: {0}", GC::GetTotalMemory( false ) );
   
   // Perform a collection of generation 0 only.
   GC::Collect( 0 );
   
   // Determine which generation myGCCol object is stored in.
   Console::WriteLine( "Generation: {0}", GC::GetGeneration( myGCCol ) );
   Console::WriteLine( "Total Memory: {0}", GC::GetTotalMemory( false ) );
   
   // Perform a collection of all generations up to and including 2.
   GC::Collect( 2 );
   
   // Determine which generation myGCCol object is stored in.
   Console::WriteLine( "Generation: {0}", GC::GetGeneration( myGCCol ) );
   Console::WriteLine( "Total Memory: {0}", GC::GetTotalMemory( false ) );
}

using System;

namespace GCCollectIntExample
{
    class MyGCCollectClass
    {
        private const long maxGarbage = 1000;
      
        static void Main()
        {
            MyGCCollectClass myGCCol = new MyGCCollectClass();

            // Determine the maximum number of generations the system
	    // garbage collector currently supports.
            Console.WriteLine("The highest generation is {0}", GC.MaxGeneration);
            
            myGCCol.MakeSomeGarbage();

            // Determine which generation myGCCol object is stored in.
            Console.WriteLine("Generation: {0}", GC.GetGeneration(myGCCol));
            
            // Determine the best available approximation of the number 
	    // of bytes currently allocated in managed memory.
            Console.WriteLine("Total Memory: {0}", GC.GetTotalMemory(false));
            
            // Perform a collection of generation 0 only.
            GC.Collect(0);
            
            // Determine which generation myGCCol object is stored in.
            Console.WriteLine("Generation: {0}", GC.GetGeneration(myGCCol));
            
            Console.WriteLine("Total Memory: {0}", GC.GetTotalMemory(false));
            
            // Perform a collection of all generations up to and including 2.
            GC.Collect(2);
            
            // Determine which generation myGCCol object is stored in.
            Console.WriteLine("Generation: {0}", GC.GetGeneration(myGCCol));
            Console.WriteLine("Total Memory: {0}", GC.GetTotalMemory(false));
            Console.Read();
        }

        void MakeSomeGarbage()
        {
            Version vt;

            for(int i = 0; i < maxGarbage; i++)
            {
                // Create objects and release them to fill up memory
		// with unused objects.
                vt = new Version();
            }
        }
    }
}
Imports System

Namespace GCCollectInt_Example
    Class MyGCCollectClass
        Private maxGarbage As Long = 10000

        Public Shared Sub Main()
            Dim myGCCol As New MyGCCollectClass

            'Determine the maximum number of generations the system
            'garbage collector currently supports.
            Console.WriteLine("The highest generation is {0}", GC.MaxGeneration)

            myGCCol.MakeSomeGarbage()

            'Determine which generation myGCCol object is stored in.
            Console.WriteLine("Generation: {0}", GC.GetGeneration(myGCCol))

            'Determine the best available approximation of the number 
            'of bytes currently allocated in managed memory.
            Console.WriteLine("Total Memory: {0}", GC.GetTotalMemory(False))

            'Perform a collection of generation 0 only.
            GC.Collect(0)

            'Determine which generation myGCCol object is stored in.
            Console.WriteLine("Generation: {0}", GC.GetGeneration(myGCCol))

            Console.WriteLine("Total Memory: {0}", GC.GetTotalMemory(False))

            'Perform a collection of all generations up to and including 2.
            GC.Collect(2)

            'Determine which generation myGCCol object is stored in.
            Console.WriteLine("Generation: {0}", GC.GetGeneration(myGCCol))
            Console.WriteLine("Total Memory: {0}", GC.GetTotalMemory(False))
            Console.Read()

        End Sub


        Sub MakeSomeGarbage()
            Dim vt As Version

            Dim i As Integer
            For i = 0 To maxGarbage - 1
                'Create objects and release them to fill up memory
                'with unused objects.
                vt = New Version
            Next i
        End Sub
    End Class
End Namespace

Remarques

Le garbage collector est un composant du common language runtime qui contrôle l’allocation et la libération de mémoire managée.The garbage collector is a common language runtime component that controls the allocation and release of managed memory. Les méthodes dans cette classe influencent lorsque le garbage collection est effectué sur un objet lorsque les ressources allouées par un objet sont libérées.The methods in this class influence when garbage collection is performed on an object and when resources allocated by an object are released. Propriétés de cette classe fournissent des informations sur la quantité totale de mémoire disponible dans le système et la catégorie d’âge ou la génération, de mémoire allouée à un objet.Properties in this class provide information about the total amount of memory available in the system and the age category, or generation, of memory allocated to an object.

Le garbage collector effectue le suivi et libère des objets alloués dans la mémoire managée.The garbage collector tracks and reclaims objects allocated in managed memory. Périodiquement, le garbage collector exécute le garbage collection pour libérer de la mémoire allouée aux objets pour lesquels il n’existe pas de références valides.Periodically, the garbage collector performs garbage collection to reclaim memory allocated to objects for which there are no valid references. Le garbage collection se produit automatiquement quand une demande de mémoire ne peut pas être satisfaite à l’aide de la mémoire disponible.Garbage collection happens automatically when a request for memory cannot be satisfied using available free memory. Une application peut également forcer un garbage collection à l’aide du Collect (méthode).Alternatively, an application can force garbage collection using the Collect method.

Le garbage collection se compose des étapes suivantes :Garbage collection consists of the following steps:

  1. Le garbage collector recherche les objets managés qui sont référencés dans le code managé.The garbage collector searches for managed objects that are referenced in managed code.

  2. Le garbage collector tente de finaliser des objets qui ne sont pas référencés.The garbage collector tries to finalize objects that are not referenced.

  3. Le garbage collector libère des objets qui ne sont pas référencés et récupère leur mémoire.The garbage collector frees objects that are not referenced and reclaims their memory.

Cette rubrique comporte les sections suivantes :This topic includes the following sections:

Le garbage collector et les ressources non managées The garbage collector and unmanaged resources
Vieillissement des objets et des générations Object aging and generations
Interdire le garbage collectionDisallowing garbage collection

Le garbage collector et les ressources non managéesThe garbage collector and unmanaged resources

Au cours d’une collection, le garbage collector ne libère pas un objet s’il trouve une ou plusieurs références à l’objet dans le code managé.During a collection, the garbage collector will not free an object if it finds one or more references to the object in managed code. Toutefois, le garbage collector ne reconnaît pas les références à un objet à partir de code non managé et peut libérer des objets qui sont utilisés exclusivement en code non managé, sauf si explicitement empêché.However, the garbage collector does not recognize references to an object from unmanaged code, and might free objects that are being used exclusively in unmanaged code unless explicitly prevented from doing so. Le KeepAlive méthode fournit un mécanisme qui empêche le garbage collector de collecter des objets qui sont en cours d’utilisation dans le code non managé.The KeepAlive method provides a mechanism that prevents the garbage collector from collecting objects that are still in use in unmanaged code.

À l’exception des allocations de mémoire managée, les implémentations du garbage collector ne conservent pas les informations sur les ressources détenues par un objet, telles que les descripteurs de fichiers ou des connexions de base de données.Aside from managed memory allocations, implementations of the garbage collector do not maintain information about resources held by an object, such as file handles or database connections. Lorsqu’un type utilise des ressources non managées doivent être libérées avant que les instances du type sont récupérés, le type peut implémenter un finaliseur.When a type uses unmanaged resources that must be released before instances of the type are reclaimed, the type can implement a finalizer.

Dans la plupart des cas, les finaliseurs sont implémentés en substituant la Object.Finalize méthode ; Toutefois, les types écrits en c# ou C++ implémentent des destructeurs que les compilateurs transforment en une substitution de Object.Finalize.In most cases, finalizers are implemented by overriding the Object.Finalize method; however, types written in C# or C++ implement destructors, which compilers turn into an override of Object.Finalize. Dans la plupart des cas, si un objet a un finaliseur, le garbage collector l’appelle avant de libérer l’objet.In most cases, if an object has a finalizer, the garbage collector calls it prior to freeing the object. Toutefois, le garbage collector n’est pas nécessaire d’appeler les finaliseurs dans toutes les situations ; par exemple, le SuppressFinalize méthode empêche explicitement un finaliseur d’objet d’être appelée.However, the garbage collector is not required to call finalizers in all situations; for example, the SuppressFinalize method explicitly prevents an object's finalizer from being called. En outre, le garbage collector n’est pas nécessaire d’utiliser un thread spécifique pour finaliser les objets, ou garantit l’ordre dans lequel les finaliseurs sont appelés pour les objets qui se référencent mutuellement, mais sont disponibles pour le garbage collection.Also, the garbage collector is not required to use a specific thread to finalize objects, or guarantee the order in which finalizers are called for objects that reference each other but are otherwise available for garbage collection.

Dans les scénarios où les ressources doivent être libérées à un moment donné, les classes peuvent implémenter la IDisposable interface, qui contient le IDisposable.Dispose méthode qui effectue les tâches de gestion et de nettoyage des ressources.In scenarios where resources must be released at a specific time, classes can implement the IDisposable interface, which contains the IDisposable.Dispose method that performs resource management and cleanup tasks. Classes qui implémentent Dispose doit spécifier, dans le cadre de leur contrat, si et quand les consommateurs de classe appellent la méthode pour nettoyer l’objet.Classes that implement Dispose must specify, as part of their class contract, if and when class consumers call the method to clean up the object. Le garbage collector ne pas, par défaut, appelez le Dispose (méthode) ; Toutefois, les implémentations de la Dispose méthode peut appeler des méthodes dans la GC classe pour personnaliser le comportement de la finalisation du garbage collector.The garbage collector does not, by default, call the Dispose method; however, implementations of the Dispose method can call methods in the GC class to customize the finalization behavior of the garbage collector.

Pour plus d’informations sur la finalisation de l’objet et le modèle de suppression, consultez de nettoyage des ressources non managées.For more information on object finalization and the dispose pattern, see Cleaning Up Unmanaged Resources.

Vieillissement des objets et des générationsObject aging and generations

Le garbage collector dans le common language runtime prend en charge le vieillissement des objets à l’aide de générations.The garbage collector in the common language runtime supports object aging using generations. Une génération est une unité de mesure de l’âge relatif des objets en mémoire.A generation is a unit of measure of the relative age of objects in memory. Le numéro de génération, ou l’âge, d’un objet indique la génération à laquelle appartient un objet.The generation number, or age, of an object indicates the generation to which an object belongs. Objets créés plus récemment font partie des nouvelles générations et possèdent des numéros de génération plus faibles que le cycle des objets créés précédemment dans la vie de l’application.Objects created more recently are part of newer generations, and have lower generation numbers than objects created earlier in the application life cycle. Les objets dans la génération la plus récente sont dans la génération 0.Objects in the most recent generation are in generation 0. Cette implémentation du garbage collector prend en charge trois générations d’objets, les générations 0, 1 et 2.This implementation of the garbage collector supports three generations of objects, generations 0, 1, and 2. Vous pouvez récupérer la valeur de la MaxGeneration propriété afin de déterminer le nombre maximal de générations prises en charge par le système.You can retrieve the value of the MaxGeneration property to determine the maximum generation number supported by the system.

Vieillissement des objets permet aux applications de nettoyage de la cible à un ensemble spécifique de générations au lieu de demander au garbage collector évaluer toutes les générations.Object aging allows applications to target garbage collection at a specific set of generations rather than requiring the garbage collector to evaluate all generations. Les surcharges de la Collect méthode qui incluent un generation paramètre permettent de spécifier la génération la plus ancienne pour être nettoyées.Overloads of the Collect method that include a generation parameter allow you to specify the oldest generation to be garbage collected.

Interdire le garbage collectionDisallowing garbage collection

En commençant par le .NET Framework 4.6.NET Framework 4.6, le garbage collector prend en charge un mode sans région GC latence qui peut être utilisé pendant l’exécution de chemins critiques dans laquelle les garbage collection peut nuire aux performances de l’application.Starting with the .NET Framework 4.6.NET Framework 4.6, the garbage collector supports a no GC region latency mode that can be used during the execution of critical paths in which garbage collection can adversely affect an app's performance. Le mode sans région GC latence nécessite que vous spécifiez une quantité de mémoire pouvant être allouée sans interférence du garbage collector.The no GC region latency mode requires that you specify an amount of memory that can be allocated without interference from the garbage collector. Si le runtime peut allouer cette mémoire, le runtime ne sera pas effectuer un garbage collection pendant l’exécution de code dans le chemin critique.If the runtime can allocate that memory, the runtime will not perform a garbage collection while code in the critical path is executing.

Vous définissez le début du chemin critique sans région GC en appelant une des surcharges de la TryStartNoGCRegion.You define the beginning of the critical path of the no GC region by calling one of the overloads of the TryStartNoGCRegion. Vous spécifiez la fin de son chemin d’accès critique en appelant le EndNoGCRegion (méthode).You specify the end of its critical path by calling the EndNoGCRegion method.

Vous ne pouvez pas imbriquer des appels à la TryStartNoGCRegion (méthode) et vous devez appeler uniquement la EndNoGCRegion méthode si le runtime est actuellement en mode de latence sans région GC.You cannot nest calls to the TryStartNoGCRegion method, and you should only call the EndNoGCRegion method if the runtime is currently in no GC region latency mode. En d’autres termes, vous ne devez pas appeler TryStartNoGCRegion plusieurs fois (après le premier appel de méthode, les appels suivants ne réussissent pas), et vous ne devriez pas les appels à EndNoGCRegion réussisse parce que le premier appel à TryStartNoGCRegion a réussi.In other words, you should not call TryStartNoGCRegion multiple times (after the first method call, subsequent calls will not succeed), and you should not expect calls to EndNoGCRegion to succeed just because the first call to TryStartNoGCRegion succeeded.

Propriétés

MaxGeneration MaxGeneration MaxGeneration MaxGeneration

Obtient le nombre maximal de générations actuellement pris en charge par le système.Gets the maximum number of generations that the system currently supports.

Méthodes

AddMemoryPressure(Int64) AddMemoryPressure(Int64) AddMemoryPressure(Int64) AddMemoryPressure(Int64)

Informe l'exécution d'une allocation volumineuse de mémoire non managée qui doit être prise en considération lors de la planification du garbage collection.Informs the runtime of a large allocation of unmanaged memory that should be taken into account when scheduling garbage collection.

CancelFullGCNotification() CancelFullGCNotification() CancelFullGCNotification() CancelFullGCNotification()

Annule l'inscription de la notification de garbage collection.Cancels the registration of a garbage collection notification.

Collect() Collect() Collect() Collect()

Force un garbage collection immédiat sur toutes les générations.Forces an immediate garbage collection of all generations.

Collect(Int32) Collect(Int32) Collect(Int32) Collect(Int32)

Force un garbage collection immédiat de la génération 0 jusqu'à une génération spécifiée.Forces an immediate garbage collection from generation 0 through a specified generation.

Collect(Int32, GCCollectionMode) Collect(Int32, GCCollectionMode) Collect(Int32, GCCollectionMode) Collect(Int32, GCCollectionMode)

Force un garbage collection de la génération 0 jusqu'à une génération spécifiée, à une heure indiquée par une valeur GCCollectionMode.Forces a garbage collection from generation 0 through a specified generation, at a time specified by a GCCollectionMode value.

Collect(Int32, GCCollectionMode, Boolean) Collect(Int32, GCCollectionMode, Boolean) Collect(Int32, GCCollectionMode, Boolean) Collect(Int32, GCCollectionMode, Boolean)

Force un garbage collection de la génération 0 jusqu'à une génération spécifiée, à une heure indiquée par une valeur GCCollectionMode, avec une valeur indiquant si le garbage collection doit effectuer le blocage.Forces a garbage collection from generation 0 through a specified generation, at a time specified by a GCCollectionMode value, with a value specifying whether the collection should be blocking.

Collect(Int32, GCCollectionMode, Boolean, Boolean) Collect(Int32, GCCollectionMode, Boolean, Boolean) Collect(Int32, GCCollectionMode, Boolean, Boolean) Collect(Int32, GCCollectionMode, Boolean, Boolean)

Force un garbage collection de la génération 0 jusqu'à une génération spécifiée, à une heure indiquée par une valeur GCCollectionMode, avec des valeurs indiquant si le garbage collection doit effectuer le blocage et le compactage.Forces a garbage collection from generation 0 through a specified generation, at a time specified by a GCCollectionMode value, with values that specify whether the collection should be blocking and compacting.

CollectionCount(Int32) CollectionCount(Int32) CollectionCount(Int32) CollectionCount(Int32)

Retourne le nombre de fois que le garbage collection s’est produit pour la génération d’objets spécifiée.Returns the number of times garbage collection has occurred for the specified generation of objects.

EndNoGCRegion() EndNoGCRegion() EndNoGCRegion() EndNoGCRegion()

Termine le mode de latence sans région GC.Ends the no GC region latency mode.

GetAllocatedBytesForCurrentThread() GetAllocatedBytesForCurrentThread() GetAllocatedBytesForCurrentThread() GetAllocatedBytesForCurrentThread()

Obtient le nombre total d’octets alloués au thread actuel depuis le début de sa durée de vie.Gets the total number of bytes allocated to the current thread since the beginning of its lifetime.

GetGeneration(Object) GetGeneration(Object) GetGeneration(Object) GetGeneration(Object)

Retourne le numéro de la génération actuelle de l'objet spécifié.Returns the current generation number of the specified object.

GetGeneration(WeakReference) GetGeneration(WeakReference) GetGeneration(WeakReference) GetGeneration(WeakReference)

Retourne le numéro de la génération actuelle de la cible d'une référence faible spécifiée.Returns the current generation number of the target of a specified weak reference.

GetTotalMemory(Boolean) GetTotalMemory(Boolean) GetTotalMemory(Boolean) GetTotalMemory(Boolean)

Récupère le nombre d'octets qu'il est actuellement prévu d'allouer.Retrieves the number of bytes currently thought to be allocated. Un paramètre indique si cette méthode peut attendre une courte période de temps avant de retourner une réponse, pour permettre au système d'effectuer un garbage collection et de finaliser les objets.A parameter indicates whether this method can wait a short interval before returning, to allow the system to collect garbage and finalize objects.

KeepAlive(Object) KeepAlive(Object) KeepAlive(Object) KeepAlive(Object)

Référence l'objet spécifié, ce qui le rend inéligible pour le garbage collection du début de la routine actuelle jusqu'au point où cette méthode est appelée.References the specified object, which makes it ineligible for garbage collection from the start of the current routine to the point where this method is called.

RegisterForFullGCNotification(Int32, Int32) RegisterForFullGCNotification(Int32, Int32) RegisterForFullGCNotification(Int32, Int32) RegisterForFullGCNotification(Int32, Int32)

Spécifie qu’une notification de garbage collection doit être émise quand les conditions sont favorables à un garbage collection complet et quand celui-ci est terminé.Specifies that a garbage collection notification should be raised when conditions favor full garbage collection and when the collection has been completed.

RemoveMemoryPressure(Int64) RemoveMemoryPressure(Int64) RemoveMemoryPressure(Int64) RemoveMemoryPressure(Int64)

Informe l’exécution que la mémoire non managée a été libérée et n’a plus besoin d’être prise en compte lors de la planification du garbage collection.Informs the runtime that unmanaged memory has been released and no longer needs to be taken into account when scheduling garbage collection.

ReRegisterForFinalize(Object) ReRegisterForFinalize(Object) ReRegisterForFinalize(Object) ReRegisterForFinalize(Object)

Demande que le système appelle le finaliseur pour l'objet spécifié, pour lequel SuppressFinalize(Object) a été précédemment appelé.Requests that the system call the finalizer for the specified object for which SuppressFinalize(Object) has previously been called.

SuppressFinalize(Object) SuppressFinalize(Object) SuppressFinalize(Object) SuppressFinalize(Object)

Demande que le Common Language Runtime n'appelle pas le finaliseur pour l'objet spécifié.Requests that the common language runtime not call the finalizer for the specified object.

TryStartNoGCRegion(Int64) TryStartNoGCRegion(Int64) TryStartNoGCRegion(Int64) TryStartNoGCRegion(Int64)

Tente d'interdire le garbage collection pendant l'exécution d'un chemin d'accès critique si une quantité de mémoire spécifiée est disponible.Attempts to disallow garbage collection during the execution of a critical path if a specified amount of memory is available.

TryStartNoGCRegion(Int64, Boolean) TryStartNoGCRegion(Int64, Boolean) TryStartNoGCRegion(Int64, Boolean) TryStartNoGCRegion(Int64, Boolean)

Tente d'interdire le garbage collection pendant l'exécution d'un chemin d'accès critique si une quantité de mémoire spécifiée est disponible, et contrôle si le garbage collector effectue un garbage collection de blocage complet si la mémoire initialement disponible est insuffisante.Attempts to disallow garbage collection during the execution of a critical path if a specified amount of memory is available, and controls whether the garbage collector does a full blocking garbage collection if not enough memory is initially available.

TryStartNoGCRegion(Int64, Int64) TryStartNoGCRegion(Int64, Int64) TryStartNoGCRegion(Int64, Int64) TryStartNoGCRegion(Int64, Int64)

Tente d'interdire le garbage collection pendant l'exécution d'un chemin d'accès critique si une quantité de mémoire spécifiée est disponible pour le tas d'objets volumineux et le tas de petits objets.Attempts to disallow garbage collection during the execution of a critical path if a specified amount of memory is available for the large object heap and the small object heap.

TryStartNoGCRegion(Int64, Int64, Boolean) TryStartNoGCRegion(Int64, Int64, Boolean) TryStartNoGCRegion(Int64, Int64, Boolean) TryStartNoGCRegion(Int64, Int64, Boolean)

Tente de suspendre le garbage collection pendant l'exécution d'un chemin d'accès critique si une quantité de mémoire suffisante spécifiée est disponible pour le tas d'objets volumineux et le tas de petits objets, et contrôle si le garbage collector effectue un garbage collection de blocage complet si la mémoire initialement disponible est insuffisante.Attempts to disallow garbage collection during the execution of a critical path if a specified amount of memory is available for the large object heap and the small object heap, and controls whether the garbage collector does a full blocking garbage collection if not enough memory is initially available.

WaitForFullGCApproach() WaitForFullGCApproach() WaitForFullGCApproach() WaitForFullGCApproach()

Retourne l'état d'une notification inscrite pour déterminer si un garbage collection de blocage complet par le Common Language Runtime est imminent.Returns the status of a registered notification for determining whether a full, blocking garbage collection by the common language runtime is imminent.

WaitForFullGCApproach(Int32) WaitForFullGCApproach(Int32) WaitForFullGCApproach(Int32) WaitForFullGCApproach(Int32)

Retourne, dans le délai d'attente spécifié, l'état d'une notification inscrite pour déterminer si un garbage collection de blocage complet par le Common Language Runtime est imminent.Returns, in a specified time-out period, the status of a registered notification for determining whether a full, blocking garbage collection by the common language runtime is imminent.

WaitForFullGCComplete() WaitForFullGCComplete() WaitForFullGCComplete() WaitForFullGCComplete()

Retourne l'état d'une notification inscrite pour déterminer si un garbage collection de blocage complet par le Common Language Runtime est terminé.Returns the status of a registered notification for determining whether a full, blocking garbage collection by the common language runtime has completed.

WaitForFullGCComplete(Int32) WaitForFullGCComplete(Int32) WaitForFullGCComplete(Int32) WaitForFullGCComplete(Int32)

Retourne, dans le délai d'attente spécifié, l'état d'une notification inscrite pour déterminer si un garbage de collection de blocage complet par le Common Language Runtime est terminé.Returns, in a specified time-out period, the status of a registered notification for determining whether a full, blocking garbage collection by common language the runtime has completed.

WaitForPendingFinalizers() WaitForPendingFinalizers() WaitForPendingFinalizers() WaitForPendingFinalizers()

Suspend le thread actif jusqu'à ce que le thread traitant la file d'attente des finaliseurs ait vidé cette file d'attente.Suspends the current thread until the thread that is processing the queue of finalizers has emptied that queue.

S’applique à

Voir aussi