Cette documentation est archivée et n’est pas conservée.

GC, classe

Mise à jour : Juillet 2008

Contrôle le garbage collector (ramasse-miettes) du système, un service qui récupère automatiquement la mémoire inutilisée.

Espace de noms :  System
Assembly :  mscorlib (dans mscorlib.dll)

public static class GC
public final class GC
public final class GC

Les méthodes dans cette classe influencent le moment où un garbage collection est effectué sur un objet et les ressources allouées par un objet sont libérées. Les propriétés dans cette classe fournissent des informations sur la quantité totale de mémoire disponible dans le système et catégorie d'âge, ou génération, de mémoire allouée à un objet.

Le garbage collector effectue le suivi des objets alloués dans la mémoire managée et les récupère. Le garbage collector exécute régulièrement des garbage collections pour récupérer la mémoire allouée aux objets qui ne possèdent pas de références valides. Le garbage collection est exécuté automatiquement lorsqu'une demande de mémoire ne peut pas être satisfaite en utilisant la mémoire libre de disponible. Une application peut également forcer un garbage collection à l'aide de la méthode Collect.

Un garbage collection comprend les étapes suivantes :

  1. Le garbage collector recherche les objets managés qui sont référencés dans du code managé.

  2. Le garbage collector essaie de finaliser les objets qui ne sont pas référencés.

  3. Le garbage collector libère les objets qui ne sont pas référencés et récupère leur mémoire.

Au cours d'un garbage collection, le garbage collector ne libère pas un objet s'il trouve une ou plusieurs références à cet objet dans du code managé. Cependant, 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 dans du code non managé, à moins qu'il ne soit explicitement empêché de procéder ainsi. La méthode KeepAlive fournit un mécanisme qui empêche le garbage collector de collecter des objets qui sont utilisés dans du code non managé.

Outre les allocations de mémoire managée, les implémentations du garbage collector ne conservent pas d'informations sur les ressources détenues par un objet, telles que les handles de fichiers ou les connexions à des bases de données. Lorsqu'un type utilise des ressources non managées qui doivent être libérées avant que des instances du type ne soient récupérées, le type peut implémenter un finaliseur.

Dans la plupart des cas, les finaliseurs sont implémentés en substituant la méthode Object.Finalize ; cependant, les types écrits en C# ou en C++ implémentent des destructeurs que les compilateurs transforment en une substitution de Object.Finalize. Dans la plupart des cas, si un objet a un finaliseur, le garbage collector l'appelle avant de libérer l'objet. Toutefois, le garbage collector n'est pas indispensable pour appeler des finaliseurs dans toutes les situations ; par exemple, la méthode SuppressFinalize empêche explicitement un finaliseur d'être appelé. Par ailleurs, le garbage collector n'utilise pas nécessairement un thread spécifique pour finaliser les objets et ne garantit pas l'ordre dans lequel les finaliseurs sont appelés pour les objets qui se référencent mutuellement, mais qui sont toutefois disponibles pour un garbage collection.

Dans les scénarios où les ressources doivent être libérées à un instant précis, les classes peuvent implémenter l'interface IDisposable qui contient la méthode IDisposable.Dispose qui exécute la gestion des ressources et les tâches de nettoyage. Les classes qui implémentent Dispose doivent spécifier, dans le cadre de leur contrat, si et à quel moment les consommateurs de classe appellent la méthode pour nettoyer l'objet. Par défaut, le garbage collector n'appelle pas la méthode Dispose ; cependant, les implémentations de la méthode Dispose peuvent appeler des méthodes dans la classe GC pour personnaliser le comportement de finalisation du garbage collector.

Il est recommandé, sans toutefois être obligatoire, que les garbage collectors prennent en charge le vieillissement des objets utilisant des générations. Une génération est une unité de mesure de l'âge relatif des objets en mémoire. Le numéro de la génération, ou âge, d'un objet indique la génération à laquelle un objet appartient. Les objets créés récemment font partie des nouvelles générations et possèdent des numéros de génération inférieurs à ceux des objets créés plus tôt dans le cycle de vie de l'application. Les objets dans la génération la plus récente appartiennent à la génération zéro.

Remarques à l'attention des implémenteurs :

Cette implémentation du garbage collector prend en charge trois générations d'objets.

MaxGeneration est utilisé pour déterminer le nombre maximal de générations pris en charge par le système. Le vieillissement des objets permet aux applications de cibler le garbage collection sur un ensemble spécifique de générations au lieu de demander au garbage collector d'évaluer toutes les générations.

L'exemple suivant utilise plusieurs méthodes GC pour obtenir des informations sur la génération et la mémoire d'un bloc d'objets inutilisés, et les imprimer à la console. Les objets inutilisés sont ensuite rassemblés et les totaux de mémoire résultants sont affichés.

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


package GCCollectIntExample; 

import System.* ;

class MyGCCollectClass
{
    private static final long maxGarbage = 1000;

    public static void main(String[] args)
    {
        MyGCCollectClass myGCCol = new MyGCCollectClass();

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

        // Determine which generation myGCCol object is stored in.
        Console.WriteLine("Generation: {0}", 
            System.Convert.ToString(GC.GetGeneration(myGCCol)));

        // Determine the best available approximation of the number 
        // of bytes currently allocated in managed memory.
        Console.WriteLine("Total Memory: {0}", 
            System.Convert.ToString(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}", 
            System.Convert.ToString(GC.GetGeneration(myGCCol)));
        Console.WriteLine("Total Memory: {0}", 
            System.Convert.ToString(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}", 
            System.Convert.ToString(GC.GetGeneration(myGCCol)));
        Console.WriteLine("Total Memory: {0}", 
            System.Convert.ToString(GC.GetTotalMemory(false)));
        Console.Read();
    } //main

    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();
        }
    } //MakeSomeGarbage
} //MyGCCollectClass


Tous les membres static (Shared en Visual Basic) publics de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.

Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professionnel Édition x64, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile pour Smartphone, Windows Mobile pour Pocket PC, Xbox 360

Le .NET Framework et le .NET Compact Framework ne prennent pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

.NET Framework

Pris en charge dans : 3.5, 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Pris en charge dans : 3.5, 2.0, 1.0

XNA Framework

Pris en charge dans : 2.0, 1.0

Date

Historique

Raison

Juillet 2008

Ajout de documentation pour les méthodes CancelFullGCNotification, RegisterForFullGCNotification, WaitForFullGCApproach et WaitForFullGCComplete.

Modifications de fonctionnalités dans le SP1.

Afficher: