GC Classe

Référence

Définition

Espace de noms:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

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

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

Pour plus d’informations sur cette API, consultez Remarques supplémentaires sur l’API pour GC.

Propriétés

MaxGeneration

Obtient le nombre maximal de générations actuellement pris en charge par le système.

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.
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 de la notification de garbage collection.
Collect()	Force un garbage collection immédiat sur toutes les générations.
Collect(Int32)	Force un garbage collection immédiat de la génération 0 jusqu'à une génération spécifiée.
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.
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.
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.
CollectionCount(Int32)	Retourne le nombre de fois que 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 des informations de mémoire sur le garbage collection.
GetGCMemoryInfo(GCKind)	Obtient des informations de mémoire sur le garbage collection.
GetGeneration(Object)	Retourne le numéro de la génération actuelle de l'objet spécifié.
GetGeneration(WeakReference)	Retourne le numéro de la génération actuelle de la cible d'une référence faible spécifiée.
GetTotalAllocatedBytes(Boolean)	Obtient le nombre des octets alloués au cours de 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 que la fragmentation, c’est-à-dire l’espace occupé par les objets libres, prend jusqu’à 40 Mo, cette API signale 60 Mo. 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.
GetTotalPauseDuration()	Obtient le temps total suspendu dans GC depuis le début du processus.
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.
RefreshMemoryLimit()	Demande 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 émise quand les conditions sont favorables à un garbage collection complet et quand celui-ci est 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 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.
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é.
SuppressFinalize(Object)	Demande que le Common Language Runtime n'appelle pas le finaliseur pour l'objet spécifié.
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.
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.
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.
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.
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.
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.
WaitForFullGCApproach(TimeSpan)	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.
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é.
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é.
WaitForFullGCComplete(TimeSpan)	Retourne le status d’une notification inscrite indiquant si un garbage collection bloquant est terminé. Peut attendre indéfiniment une collection complète.
WaitForPendingFinalizers()	Suspend le thread actif jusqu'à ce que le thread traitant la file d'attente des finaliseurs ait vidé cette file d'attente.

S’applique à

Partage via