GC Classe

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 ref class GC sealed
public static class GC
public sealed class GC
type GC = class
Public Class GC
Public NotInheritable Class GC
Héritage
GC

Exemples

L’exemple suivant utilise plusieurs méthodes GC pour obtenir des informations sur la génération et la mémoire à propos d’un bloc d’objets inutilisés et l’imprimer dans 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 collectés et les totaux de mémoire résultants sont affichés.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();
            }
        }
    }
}
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 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 de cette classe influencent le moment où garbage collection est exécuté sur un objet et quand 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. Les 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 la 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 récupère les 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 effectue garbage collection pour libérer de la mémoire allouée aux objets pour lesquels il n’existe aucune référence valide.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 lorsqu’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 l’garbage collection à l’aide de la 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 les 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 les objets qui ne sont pas référencés et libè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 et générations d’objets Object aging and generations
Interdire le garbage collectionDisallowing garbage collection

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

Pendant 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 du code non managé et peut libérer des objets qui sont utilisés exclusivement dans du code non managé, sauf en cas d’interdiction explicite.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. La KeepAlive méthode fournit un mécanisme qui empêche le garbage collector de collecter des objets qui sont toujours utilisés dans du 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.

Hormis les allocations de mémoire managée, les implémentations du garbage collector ne maintiennent pas les informations sur les ressources détenues par un objet, telles que les handles de fichiers ou les 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 qui doivent être libérées avant que les instances du type soient récupérées, 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 obligé d’appeler des finaliseurs dans toutes les situations ; par exemple, la SuppressFinalize méthode empêche explicitement l’appel du finaliseur d’un objet.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 obligé d’utiliser un thread spécifique pour finaliser les objets, ou de garantir l’ordre dans lequel les finaliseurs sont appelés pour les objets qui se référencent mutuellement, mais qui sont sinon disponibles pour la 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 l' IDisposable interface, qui contient la 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. Les classes qui implémentent Dispose doivent spécifier, dans le cadre de leur contrat de classe, 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. Par défaut, le garbage collector n’appelle pas la Dispose méthode ; Toutefois, les implémentations de la Dispose méthode peuvent appeler des méthodes dans la GC classe pour personnaliser le comportement de 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 des objets et le modèle de suppression, consultez nettoyage des ressources non managées.For more information on object finalization and the dispose pattern, see Cleaning Up Unmanaged Resources.

Vieillissement et générations d’objetsObject aging and generations

Le garbage collector dans le common language runtime prend en charge la datation 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 â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. Les objets créés plus récemment font partie des générations plus récentes et ont des numéros de génération inférieurs aux objets créés plus tôt dans le cycle de 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 de 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, 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é pour déterminer le numéro de génération maximal pris 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.

La datation des objets permet aux applications de cibler garbage collection à un ensemble spécifique de générations plutôt que de demander au garbage collector d’é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 vous permettent de spécifier la génération la plus ancienne pour être récupérée par le garbage collector.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

À partir de la .NET Framework 4,6, le garbage collector ne prend en charge aucun mode de latence de région GC qui peut être utilisé lors de l’exécution de chemins critiques dans lesquels garbage collection peut nuire aux performances d’une application.Starting with the .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 de latence sans région GC requiert que vous spécifiiez une quantité de mémoire qui peut ê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 n’effectuera pas d’garbage collection lors de l’exécution du 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 de la région no GC en appelant l’une des surcharges de 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 critique en appelant la 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 la EndNoGCRegion méthode uniquement si le runtime n’est actuellement pas en mode de latence de 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 échoueront) et vous ne devriez pas vous attendre à ce que les appels à EndNoGCRegion aboutissent uniquement parce que le premier appel à TryStartNoGCRegion 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

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)

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.

AllocateArray<T>(Int32, Boolean)

Alloue un tableau.Allocates an array.

AllocateUninitializedArray<T>(Int32, Boolean)

Alloue un tableau tout en ignorant l’initialisation à zéro, si possible.Allocates an array while skipping zero-initialization, if possible.

CancelFullGCNotification()

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

Collect()

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

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)

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)

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)

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)

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()

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

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.

GetGCMemoryInfo()

Obtient des informations de mémoire sur le garbage collection.Gets garbage collection memory information.

GetGCMemoryInfo(GCKind)

Obtient des informations de mémoire sur le garbage collection.Gets garbage collection memory information.

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)

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.

GetTotalAllocatedBytes(Boolean)

Obtient le nombre des octets alloués au cours de la durée de vie du processus.Gets a count of the bytes allocated over the lifetime of the process.

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)

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)

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)

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)

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)

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)

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)

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)

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)

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()

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)

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()

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)

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()

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