GC Classe

Définition

Espace de noms:: System

Assemblys:: mscorlib.dll, System.Runtime.dll

Assemblys:: netstandard.dll, System.Runtime.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Source:: GC.cs

Source:: GC.cs

Source:: GC.cs

Source:: GC.cs

Source:: GC.cs

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Contrôle le garbage collector système, un service qui récupère automatiquement la mémoire inutilisée.

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: Object
GC

Exemples

L’exemple suivant utilise plusieurs méthodes GC pour obtenir des informations de génération et de mémoire sur un bloc d’objets inutilisés et l’imprimer dans la console. Les objets inutilisés sont ensuite collecté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();
            }
        }
    }
}

open System

let maxGarbage = 1000

type MyGCCollectClass() =
    member _.MakeSomeGarbage() =
        for _ = 1 to maxGarbage do
            // Create objects and release them to fill up memory with unused objects.
            Version() |> ignore

[<EntryPoint>]
let main _ =
    let myGCCol = MyGCCollectClass()

    // Determine the maximum number of generations the system
    // garbage collector currently supports.
    printfn $"The highest generation is {GC.MaxGeneration}"

    myGCCol.MakeSomeGarbage()

    // Determine which generation myGCCol object is stored in.
    printfn $"Generation: {GC.GetGeneration myGCCol}"

    // Determine the best available approximation of the number
    // of bytes currently allocated in managed memory.
    printfn $"Total Memory: {GC.GetTotalMemory false}"

    // Perform a collection of generation 0 only.
    GC.Collect 0

    // Determine which generation myGCCol object is stored in.
    printfn $"Generation: {GC.GetGeneration myGCCol}"

    printfn $"Total Memory: {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.
    printfn $"Generation: {GC.GetGeneration myGCCol}"
    printfn $"Total Memory: {GC.GetTotalMemory false}"

    0

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

La GC classe contrôle le ramasse-miettes. Le garbage collector est un composant de l'environnement d'exécution .NET qui contrôle l’allocation et la libération de la mémoire managée. Les méthodes de cette classe ont une influence quand le nettoyage de mémoire est effectué sur un objet et lorsque les ressources allouées par un objet sont libérées. 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 génération, de la mémoire allouée à un objet.

Le récupérateur de mémoire effectue le suivi et récupère les objets alloués en mémoire managée. Régulièrement, le récupérateur de mémoire réalise un nettoyage de mémoire pour récupérer la mémoire allouée aux objets pour lesquels il n’existe aucune référence valide. Le ramasse-miettes se déclenche automatiquement lorsqu’une demande de mémoire ne peut pas être satisfaite avec la mémoire libre disponible. Une application peut également forcer le nettoyage de mémoire à l’aide de la méthode Collect.

La collecte de déchets consiste en les étapes suivantes :

Le garbage collector recherche les objets managés référencés dans le code managé.
Le ramasse-miettes tente de finaliser les objets qui ne sont pas référencés.
Le ramasse-miettes libère les objets qui ne sont pas référencés et récupère leur mémoire.

Ressources non managées

Pendant un regroupement, le ramasse-miettes ne libère pas un objet s’il trouve une ou plusieurs références à l’objet dans le code géré. Toutefois, le ramasse-miettes ne reconnaît pas les références à un objet à partir d’un code non managé et peut libérer des objets utilisés exclusivement dans du code non managé, à moins qu’il ne soit explicitement empêché de le faire. 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é.

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 de base de données. 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.

Dans la plupart des cas, les finaliseurs sont implémentés en remplaçant la méthode Object.Finalize ; toutefois, les types écrits en C# ou C++ implémentent des destructeurs, que les compilateurs transforment en un remplacement de Object.Finalize. Dans la plupart des cas, si un objet a un finaliseur, le ramasse-miettes le déclenche avant de libérer l’objet. Toutefois, le récupérateur de mémoire n’est pas obligé d’appeler les finaliseurs dans toutes les circonstances ; par exemple, la méthode SuppressFinalize empêche explicitement que le finaliseur d’un objet soit appelé. En outre, le récupérateur de mémoire n'est pas obligé d'utiliser un thread spécifique pour finaliser des objets, ni de garantir l'ordre dans lequel les finaliseurs sont appelés pour des objets qui se réfèrent les uns aux autres, mais qui sont autrement disponibles pour le nettoyage de mémoire.

Dans les scénarios où les ressources doivent être publiées à un moment spécifique, les classes peuvent implémenter l’interface IDisposable , qui contient la IDisposable.Dispose méthode qui effectue des tâches de gestion des ressources et de nettoyage. Les classes qui implémentent Dispose doivent spécifier, dans le cadre de leur contrat de classe, si et quand les consommateurs de classes appellent la méthode pour nettoyer l’objet. Le garbage collector n’appelle pas par défaut 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.

Pour plus d’informations sur la finalisation de l’objet et le modèle de suppression, consultez Nettoyage des ressources non managées.

Vieillissement de l’objet et générations

Le récupérateur de mémoire dans l'environnement d'exécution commun prend en charge le vieillissement des objets grâce aux 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 génération ou l’âge d’un objet indique la génération à laquelle appartient un objet. Les objets créés plus récemment font partie des générations plus récentes et ont des nombres de génération inférieurs aux objets créés plus tôt dans le cycle de vie de l’application. Les objets de la génération la plus récente sont de génération 0. Cette implémentation du ramasse-miettes prend en charge trois niveaux d’objets : niveaux 0, 1 et 2. Vous pouvez récupérer la valeur de la MaxGeneration propriété pour déterminer le nombre maximal de génération pris en charge par le système.

Le vieillissement de l’objet permet aux applications de cibler le ramasse-miettes sur un ensemble spécifique de générations plutôt que d'exiger que le ramasse-miettes évalue toutes les générations. Les surcharges de la méthode Collect qui incluent un paramètre generation vous permettent de spécifier la génération la plus ancienne à récupérer.

Désactiver la collecte de déchets

Le collecteur de déchets prend en charge un mode de latence pour les régions sans GC, qui peut être utilisé pendant l'exécution de sections critiques où la collecte de déchets peut affecter négativement les performances d'une application. Le mode de latence de région sans GC nécessite que vous spécifiiez une quantité de mémoire pouvant être allouée sans interférence du récupérateur de mémoire. Si l'environnement d'exécution peut allouer cette mémoire, il n'effectuera pas de nettoyage de mémoire pendant l'exécution du code dans le chemin critique.

Vous définissez le début du chemin critique de la région sans GC en appelant l'une des surcharges de TryStartNoGCRegion. Vous spécifiez la fin de son chemin critique en appelant la EndNoGCRegion méthode.

Vous ne pouvez pas imbriquer les appels à la méthode TryStartNoGCRegion, et vous devez uniquement appeler la méthode EndNoGCRegion si l'environnement d'exécution est actuellement en mode de latence sans GC. En d’autres termes, vous ne devez pas appeler TryStartNoGCRegion plusieurs fois (après le premier appel, les appels suivants ne réussiront pas), et vous ne devez pas vous attendre à ce que les appels à EndNoGCRegion réussissent simplement parce que le premier appel à TryStartNoGCRegion a réussi.

Propriétés

Nom	Description
MaxGeneration	Obtient le nombre maximal de générations prises en charge par le système.

Méthodes

Nom	Description
AddMemoryPressure(Int64)	Informe le runtime d’une allocation importante de mémoire non managée qui doit être prise en compte lors de la planification du garbage collection.
AllocateArray<T>(Int32, Boolean)	Alloue un tableau.
AllocateUninitializedArray<T>(Int32, Boolean)	Alloue un tableau tout en ignorant l’initialisation zéro, si possible.
CancelFullGCNotification()	Annule l’inscription d’une notification de garbage collection.
Collect()	Force un garbage collection immédiat de toutes les générations.
Collect(Int32, GCCollectionMode, Boolean, Boolean)	Force un garbage collection de la génération 0 à une génération spécifiée, à la fois spécifiée par une GCCollectionMode valeur, avec des valeurs qui spécifient si le regroupement doit être bloquant et compacté.
Collect(Int32, GCCollectionMode, Boolean)	Force un garbage collection de la génération 0 à une génération spécifiée, à une heure spécifiée par une GCCollectionMode valeur, avec une valeur spécifiant si la collection doit être bloquée.
Collect(Int32, GCCollectionMode)	Force un garbage collection de génération 0 à une génération spécifiée, à la fois spécifiée par une GCCollectionMode valeur.
Collect(Int32)	Force un garbage collection immédiat de la génération 0 à une génération spécifiée.
CollectionCount(Int32)	Retourne le nombre de fois où le garbage collection s’est produit pour la génération d’objets spécifiée.
EndNoGCRegion()	Termine le mode de latence sans région GC.
GetAllocatedBytesForCurrentThread()	Obtient le nombre total d’octets alloués au thread actuel depuis le début de sa durée de vie.
GetConfigurationVariables()	Obtient les configurations utilisées par le garbage collector.
GetGCMemoryInfo()	Obtient les informations de mémoire du garbage collection.
GetGCMemoryInfo(GCKind)	Obtient les informations de mémoire du garbage collection.
GetGeneration(Object)	Retourne le numéro de génération actuel de l’objet spécifié.
GetGeneration(WeakReference)	Retourne le numéro de génération actuel de la cible d’une référence faible spécifiée.
GetTotalAllocatedBytes(Boolean)	Obtient le nombre d’octets alloués pendant la durée de vie du processus. La valeur retournée n’inclut aucune allocation native.
GetTotalMemory(Boolean)	Récupère la taille du tas à l’exclusion de la fragmentation. Par exemple, si la taille totale du tas GC est de 100 Mo et de fragmentation, c’est-à-dire si l’espace pris en charge par les objets libres prend jusqu’à 40 Mo, cette API signale 60 Mo. Un paramètre indique si cette méthode peut attendre un court intervalle avant de retourner, pour permettre au système de collecter le garbage et de finaliser les objets.
GetTotalPauseDuration()	Obtient la durée totale suspendue dans GC depuis le début du processus.
KeepAlive(Object)	Fait 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.
RefreshMemoryLimit()	Indique au Garbage Collector de se reconfigurer en détectant les différentes limites de mémoire sur le système.
RegisterForFullGCNotification(Int32, Int32)	Spécifie qu’une notification de garbage collection doit être déclenchée lorsque les conditions favorisent le garbage collection complet et lorsque le regroupement a été terminé.
RegisterNoGCRegionCallback(Int64, Action)	Inscrit un rappel à appeler lorsqu’une certaine quantité de mémoire est allouée dans la région GC.
RemoveMemoryPressure(Int64)	Informe le runtime que la mémoire non managée a été libérée et ne doit plus être prise en compte lors de la planification du garbage collection.
ReRegisterForFinalize(Object)	Demande que le système appelle le finaliseur pour l’objet spécifié pour lequel SuppressFinalize(Object) il a été appelé précédemment.
SuppressFinalize(Object)	Demande que le Common Language Runtime n’appelle pas le finaliseur pour l’objet spécifié.
TryStartNoGCRegion(Int64, Boolean)	Tente de interdire le garbage collection pendant l’exécution d’un chemin critique si une quantité de mémoire spécifiée est disponible et contrôle si le garbage collector effectue un nettoyage complet du garbage collection s’il n’y a pas suffisamment de mémoire initialement disponible.
TryStartNoGCRegion(Int64, Int64, Boolean)	Tente de interdire le garbage collection pendant l’exécution d’un chemin critique si une quantité de mémoire spécifiée est disponible pour le tas d’objets volumineux et le tas d’objets de petite taille, et contrôle si le garbage collector effectue un garbage collection bloquant complet s’il n’y a pas suffisamment de mémoire initialement disponible.
TryStartNoGCRegion(Int64, Int64)	Tente de interdire le garbage collection pendant l’exécution d’un chemin critique si une quantité de mémoire spécifiée est disponible pour le tas d’objets volumineux et le tas d’objets de petite taille.
TryStartNoGCRegion(Int64)	Tente de interdire le garbage collection pendant l’exécution d’un chemin critique si une quantité de mémoire spécifiée est disponible.
WaitForFullGCApproach()	Retourne l’état d’une notification inscrite pour déterminer si un garbage collection complet et bloquant par le Common Language Runtime est imminent.
WaitForFullGCApproach(Int32)	Retourne, dans un délai d’expiration spécifié, l’état d’une notification inscrite pour déterminer si un garbage collection complet bloquant par le Common Language Runtime est imminent.
WaitForFullGCApproach(TimeSpan)	Retourne, dans un délai d’expiration spécifié, l’état d’une notification inscrite pour déterminer si un garbage collection complet bloquant par le Common Language Runtime est imminent.
WaitForFullGCComplete()	Retourne l’état d’une notification inscrite pour déterminer si un garbage collection complet et bloquant par le Common Language Runtime s’est terminé.
WaitForFullGCComplete(Int32)	Retourne, dans un délai d’attente spécifié, l’état d’une notification inscrite pour déterminer si un garbage collection complet et bloquant le garbage collection par le langage commun que le runtime a terminé.
WaitForFullGCComplete(TimeSpan)	Retourne l’état d’une notification inscrite concernant la fin d’un garbage collection bloquant. Peut attendre indéfiniment une collection complète.
WaitForPendingFinalizers()	Suspend le thread actuel jusqu’à ce que le thread qui traite la file d’attente des finaliseurs ait vidé cette file d’attente.

S’applique à

Voir aussi

Commentaires

Cette page a-t-elle été utile ?