GC.Collect Méthode

Référence

Définition

Espace de noms:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

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.

Force un garbage collection.

Surcharges

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.

Collect()

Source:: GC.CoreCLR.cs

Source:: GC.CoreCLR.cs

Source:: GC.CoreCLR.cs

Force un garbage collection immédiat sur toutes les générations.

public:
 static void Collect();

public static void Collect ();

static member Collect : unit -> unit

Public Shared Sub Collect ()

Exemples

L’exemple suivant montre comment utiliser la Collect méthode pour effectuer une collection sur toutes les générations de mémoire. Le code génère un certain nombre d’objets inutilisés, puis appelle la Collect méthode pour les propre à partir de la mémoire.

using namespace System;

const int maxGarbage = 1000;

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

void main()
{
   // Put some objects in memory.
   MakeSomeGarbage();
   Console::WriteLine("Memory used before collection:       {0:N0}", 
                      GC::GetTotalMemory( false ) );
   
   // Collect all generations of memory.
   GC::Collect();
   Console::WriteLine("Memory used after full collection:   {0:N0}", 
                      GC::GetTotalMemory( true ) );
}
// The output from the example resembles the following:
//       Memory used before collection:       79,392
//       Memory used after full collection:   52,640

using System;

class MyGCCollectClass
{
   private const int maxGarbage = 1000;

   static void Main()
   {
      // Put some objects in memory.
      MyGCCollectClass.MakeSomeGarbage();
      Console.WriteLine("Memory used before collection:       {0:N0}",
                        GC.GetTotalMemory(false));

      // Collect all generations of memory.
      GC.Collect();
      Console.WriteLine("Memory used after full collection:   {0:N0}",
                        GC.GetTotalMemory(true));
   }

   static void MakeSomeGarbage()
   {
      Version vt;

      // Create objects and release them to fill up memory with unused objects.
      for(int i = 0; i < maxGarbage; i++) {
         vt = new Version();
      }
   }
}
// The output from the example resembles the following:
//       Memory used before collection:       79,392
//       Memory used after full collection:   52,640

open System

let maxGarbage = 1000

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

// Put some objects in memory.
makeSomeGarbage()
printfn $"Memory used before collection:       {GC.GetTotalMemory false:N0}"

// Collect all generations of memory.
GC.Collect()
printfn $"Memory used after full collection:   {GC.GetTotalMemory true:N0}"

// The output from the example resembles the following:
//       Memory used before collection:       79,392
//       Memory used after full collection:   52,640

Class MyGCCollectClass
     Private Const maxGarbage As Integer = 1000

     Shared Sub Main()
         'Put some objects in memory.
         MyGCCollectClass.MakeSomeGarbage()
         Console.WriteLine("Memory used before collection:       {0:N0}", 
                           GC.GetTotalMemory(False))

         'Collect all generations of memory.
         GC.Collect()
         Console.WriteLine("Memory used after full collection:   {0:N0}", 
                           GC.GetTotalMemory(True))
     End Sub

     Shared 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 
     End Sub
 End Class
' The output from the example resembles the following:
'       Memory used before collection:       79,392
'       Memory used after full collection:   52,640

Remarques

Utilisez cette méthode pour essayer de récupérer toute la mémoire inaccessible. Il effectue un garbage collection bloquant de toutes les générations.

Tous les objets, quelle que soit la durée pendant laquelle ils ont été en mémoire, sont considérés pour la collection ; toutefois, les objets référencés dans le code managé ne sont pas collectés. Utilisez cette méthode pour forcer le système à essayer de récupérer la quantité maximale de mémoire disponible.

À compter de .NET Framework 4.5.1, vous pouvez compacter le tas d’objets volumineux (LOH) en définissant la GCSettings.LargeObjectHeapCompactionMode propriété GCLargeObjectHeapCompactionMode.CompactOnce sur avant d’appeler la Collect méthode, comme l’illustre l’exemple suivant.

GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce;
GC.Collect();

GCSettings.LargeObjectHeapCompactionMode <- GCLargeObjectHeapCompactionMode.CompactOnce
GC.Collect()

GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce
GC.Collect()

Voir aussi

Collections forcées

S’applique à

Collect(Int32)

Source:: GC.CoreCLR.cs

Source:: GC.CoreCLR.cs

Source:: GC.CoreCLR.cs

Force un garbage collection immédiat de la génération 0 jusqu'à une génération spécifiée.

public:
 static void Collect(int generation);

public static void Collect (int generation);

static member Collect : int -> unit

Public Shared Sub Collect (generation As Integer)

Paramètres

generation: Int32

Numéro de la génération la plus ancienne devant faire l'objet d'un garbage collection.

Exceptions

ArgumentOutOfRangeException

generation n'est pas valide.

Exemples

L’exemple suivant montre comment utiliser la Collect méthode pour effectuer une collection sur des couches individuelles de mémoire. Le code génère un certain nombre d’objets inutilisés, puis appelle la Collect méthode pour les propre à partir de la mémoire.

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

Utilisez cette méthode pour essayer de récupérer la mémoire inaccessible. Toutefois, l’utilisation de cette méthode ne garantit pas que toute la mémoire inaccessible de la génération spécifiée soit récupérée.

Si le vieillissement des objets est implémenté, le garbage collector ne collecte pas les objets dont le numéro de génération est supérieur à la génération spécifiée. Si le vieillissement des objets n’est pas implémenté, le garbage collector prend en compte tous les objets pendant le garbage collection.

Utilisez la MaxGeneration propriété pour déterminer la valeur valide maximale du generation paramètre.

Pour que le garbage collector considère tous les objets, quelle que soit leur génération, utilisez la version de cette méthode qui ne prend aucun paramètre. Pour que le garbage collector récupère des objets en fonction d’un GCCollectionMode paramètre, utilisez la GC.Collect(Int32, GCCollectionMode) méthode surcharge.

Voir aussi

Collections forcées

S’applique à

Collect(Int32, GCCollectionMode)

Source:: GC.CoreCLR.cs

Source:: GC.CoreCLR.cs

Source:: GC.CoreCLR.cs

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.

public:
 static void Collect(int generation, GCCollectionMode mode);

public static void Collect (int generation, GCCollectionMode mode);

static member Collect : int * GCCollectionMode -> unit

Public Shared Sub Collect (generation As Integer, mode As GCCollectionMode)

Paramètres

generation: Int32

Numéro de la génération la plus ancienne devant faire l'objet d'un garbage collection.

mode: GCCollectionMode

Valeur d'énumération qui spécifie si le garbage collection est forcé (Default ou Forced) ou optimisé (Optimized).

Exceptions

ArgumentOutOfRangeException

generation n'est pas valide.

- ou -

mode ne fait pas partie des valeurs GCCollectionMode .

Exemples

L’exemple suivant force un garbage collection pour les objets de génération 2 avec le Optimized paramètre .

using System;

class Program
{
    static void Main(string[] args)
    {
        GC.Collect(2, GCCollectionMode.Optimized);
    }
}

open System

GC.Collect(2, GCCollectionMode.Optimized)

Class Program

    Public Shared Sub Main()
        GC.Collect(2, GCCollectionMode.Optimized)
    End Sub
End Class

Remarques

Utilisez le paramètre pour spécifier si le mode garbage collection doit se produire immédiatement ou uniquement si le temps est optimal pour récupérer des objets. L’utilisation de cette méthode ne garantit pas que toute la mémoire inaccessible de la génération spécifiée est récupérée.

Pour ajuster l’intrusion du garbage collection pendant les périodes critiques dans votre application, définissez la LatencyMode propriété .

Le garbage collector ne collecte pas les objets dont le numéro de génération est supérieur à celui spécifié par le generation paramètre. Utilisez la MaxGeneration propriété pour déterminer la valeur valide maximale de generation.

Pour que le garbage collector considère tous les objets, quelle que soit leur génération, utilisez la version de cette méthode qui ne prend aucun paramètre.

Pour que le garbage collector récupère des objets jusqu’à une génération d’objets spécifiée, utilisez la GC.Collect(Int32) méthode surcharge. Lorsque vous spécifiez la génération maximale, tous les objets sont collectés.

Voir aussi

Collections forcées

S’applique à

Collect(Int32, GCCollectionMode, Boolean)

Source:: GC.CoreCLR.cs

Source:: GC.CoreCLR.cs

Source:: GC.CoreCLR.cs

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.

public:
 static void Collect(int generation, GCCollectionMode mode, bool blocking);

public static void Collect (int generation, GCCollectionMode mode, bool blocking);

static member Collect : int * GCCollectionMode * bool -> unit

Public Shared Sub Collect (generation As Integer, mode As GCCollectionMode, blocking As Boolean)

Paramètres

generation: Int32

Numéro de la génération la plus ancienne devant faire l'objet d'un garbage collection.

mode: GCCollectionMode

Valeur d'énumération qui spécifie si le garbage collection est forcé (Default ou Forced) ou optimisé (Optimized).

blocking: Boolean

true pour effectuer un garbage collection de blocage ; false pour effectuer un garbage collection d'arrière-plan, si possible.

Exceptions

ArgumentOutOfRangeException

generation n'est pas valide.

- ou -

mode ne fait pas partie des valeurs GCCollectionMode .

Remarques

Le tableau suivant récapitule l’interaction des mode paramètres et blocking :

`mode`	`blocking` a la valeur `true`.	`blocking` a la valeur `false`.
Forced ou Default	Une collection de blocage est exécutée dès que possible. Si une collection d’arrière-plan est en cours et `generation` est 0 ou 1, le Collect(Int32, GCCollectionMode, Boolean) méthode déclenche une collection de blocage immédiatement et retourne quand la collection est terminée. Si une collection d’arrière-plan est en cours et `generation` est 2, la méthode attend que la collection d’arrière-plan soit terminée, déclenche une collection de génération 2 bloquante, puis retourne.	Une collection est exécutée dès que possible. La méthode Collect(Int32, GCCollectionMode, Boolean) demande une collection d'arrière-plan, mais cela n'est pas garanti ; selon les cas, une collection bloquante peut toujours être exécutée. Si une collection d’arrière-plan est déjà en cours, la méthode retourne immédiatement une valeur.
Optimized	Une collecte bloquante peut être exécutée, selon l'état du récupérateur de mémoire et du paramètre `generation`. Le Garbage collector tente de fournir des performances optimales.	Une collection de blocage peut être effectuée, en fonction de l’état du Garbage collector. La méthode Collect(Int32, GCCollectionMode, Boolean) demande une collection d'arrière-plan, mais cela n'est pas garanti ; selon les cas, une collection bloquante peut toujours être exécutée. Le Garbage collector tente de fournir des performances optimales. Si une collection d’arrière-plan est déjà en cours, la méthode retourne immédiatement une valeur.

Si un appel à la Collect(Int32, GCCollectionMode, Boolean) méthode effectue un garbage collection bloquant complet, vous pouvez également compacter le tas d’objets volumineux en définissant la GCSettings.LargeObjectHeapCompactionMode propriété sur avant d’appeler GCLargeObjectHeapCompactionMode.CompactOnce la Collect méthode.

S’applique à

Collect(Int32, GCCollectionMode, Boolean, Boolean)

Source:: GC.CoreCLR.cs

Source:: GC.CoreCLR.cs

Source:: GC.CoreCLR.cs

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.

public:
 static void Collect(int generation, GCCollectionMode mode, bool blocking, bool compacting);

public static void Collect (int generation, GCCollectionMode mode, bool blocking, bool compacting);

static member Collect : int * GCCollectionMode * bool * bool -> unit

Public Shared Sub Collect (generation As Integer, mode As GCCollectionMode, blocking As Boolean, compacting As Boolean)

Paramètres

generation: Int32

Numéro de la génération la plus ancienne devant faire l'objet d'un garbage collection.

mode: GCCollectionMode

Valeur d'énumération qui spécifie si le garbage collection est forcé (Default ou Forced) ou optimisé (Optimized).

blocking: Boolean

true pour effectuer un garbage collection de blocage ; false pour effectuer un garbage collection d'arrière-plan, si possible.

compacting: Boolean

true pour compacter le tas de petits objets. false pour effectuer un balayage uniquement.

Remarques

Si blocking a la valeur false, le GC décide d’effectuer un garbage collection en arrière-plan ou un garbage collection bloquant. Si compacting a la valeur true, il effectue un garbage collection bloquant.

Si compacting a la valeur true, le runtime compacte le tas d’objets de petite taille (SOH). Le tas d’objets volumineux (LOH) n’est compacté que si la propriété a la GCSettings.LargeObjectHeapCompactionMode valeur GCLargeObjectHeapCompactionMode.CompactOnce. Notez que cela inclut tous les regroupements de mémoires bloquants, et pas seulement les regroupements de mémoires de blocage complets.

Vous pouvez appeler la Collect(Int32, GCCollectionMode, Boolean, Boolean) méthode pour réduire le tas managé à la plus petite taille possible, comme l’illustre le fragment de code suivant.

GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce;
GC.Collect(2, GCCollectionMode.Forced, true, true);

GCSettings.LargeObjectHeapCompactionMode <- GCLargeObjectHeapCompactionMode.CompactOnce
GC.Collect(2, GCCollectionMode.Forced, true, true)

GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce
GC.Collect(2, GCCollectionMode.Forced, True, True)

La spécification de true l’argument compacting garantit un nettoyage de la mémoire de compactage et de blocage complet. La définition de la GCSettings.LargeObjectHeapCompactionMode propriété sur GCLargeObjectHeapCompactionMode.CompactOnce garantit que le LOH et le SOH sont compactés.

S’applique à

GC.Collect Méthode

Définition

Surcharges

Collect()

Exemples

Remarques

Voir aussi

S’applique à

Collect(Int32)

Paramètres

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

Collect(Int32, GCCollectionMode)

Paramètres

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

Collect(Int32, GCCollectionMode, Boolean)

Paramètres

Exceptions

Remarques

S’applique à

Collect(Int32, GCCollectionMode, Boolean, Boolean)

Paramètres

Remarques

S’applique à

Commentaires

Ressources supplémentaires