GC.Collect GC.Collect GC.Collect GC.Collect Method

Définition

Force un garbage collection.Forces garbage collection.

Surcharges

Collect() Collect() Collect() Collect()

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

Collect(Int32) Collect(Int32) Collect(Int32) 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) Collect(Int32, GCCollectionMode) Collect(Int32, GCCollectionMode) 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) Collect(Int32, GCCollectionMode, Boolean) Collect(Int32, GCCollectionMode, Boolean) 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) Collect(Int32, GCCollectionMode, Boolean, Boolean) Collect(Int32, GCCollectionMode, Boolean, Boolean) 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.

Collect() Collect() Collect() Collect()

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

public:
 static void Collect();
public static void Collect ();
static member Collect : unit -> unit
Public Shared Sub Collect ()

Exemples

L’exemple suivant montre comment utiliser le Collect méthode pour exécuter une collecte sur toutes les générations de mémoire.The following example demonstrates how to use the Collect method to perform a collection on all generations of memory. Le code génère un nombre d’objets inutilisés, puis appelle la Collect méthode pour les supprimer de la mémoire.The code generates a number of unused objects, and then calls the Collect method to clean them from memory.

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
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 tenter de récupérer toute la mémoire qui n’est pas accessible.Use this method to try to reclaim all memory that is inaccessible. Il effectue une garbage collection de blocage de toutes les générations.It performs a blocking garbage collection of all generations.

Tous les objets, quelle que soit la durée pendant laquelle ils ont été en mémoire, sont considérées comme dans la collection ; Toutefois, les objets qui sont référencés dans le code managé ne sont pas collectés.All objects, regardless of how long they have been in memory, are considered for collection; however, objects that are referenced in managed code are not collected. Utilisez cette méthode pour forcer le système à tenter de récupérer la quantité maximale de mémoire disponible.Use this method to force the system to try to reclaim the maximum amount of available memory.

En commençant par le .NET Framework 4.5.1.NET Framework 4.5.1, vous pouvez également compacter le tas d’objets volumineux (LOH) en définissant le GCSettings.LargeObjectHeapCompactionMode propriété GCLargeObjectHeapCompactionMode.CompactOnce avant d’appeler le Collect (méthode), comme dans l’exemple suivant illustre.Starting with the .NET Framework 4.5.1.NET Framework 4.5.1, you can compact the large object heap (LOH) by setting the GCSettings.LargeObjectHeapCompactionMode property to GCLargeObjectHeapCompactionMode.CompactOnce before calling the Collect method, as the following example illustrates.

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

Collect(Int32) Collect(Int32) Collect(Int32) 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.

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 Int32 Int32 Int32

Numéro de la génération la plus ancienne devant faire l'objet d'un garbage collection.The number of the oldest generation to be garbage collected.

Exceptions

Exemples

L’exemple suivant montre comment utiliser le Collect méthode pour effectuer un regroupement sur des couches individuelles de mémoire.The following example demonstrates how to use the Collect method to perform a collection on individual layers of memory. Le code génère un nombre d’objets inutilisés, puis appelle la Collect méthode pour les supprimer de la mémoire.The code generates a number of unused objects, and then calls the Collect method to clean them from memory.

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

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 tenter de récupérer la mémoire qui n’est pas accessible.Use this method to try to reclaim memory that is inaccessible. Toutefois, à l’aide de cette méthode ne garantit pas que la mémoire inaccessible dans la génération spécifiée soit libérée.However, using this method does not guarantee that all inaccessible memory in the specified generation is reclaimed.

Si le vieillissement des objets est implémenté, le garbage collector ne collecte pas les objets avec un numéro de génération qui est supérieur à la génération spécifiée.If object aging is implemented, the garbage collector does not collect objects with a generation number that is higher than the specified generation. Si la chronologie de l’objet n’est pas implémentée, le garbage collector considère que tous les objets pendant le garbage collection.If object aging is not implemented, the garbage collector considers all objects during the garbage collection.

Utilisez le MaxGeneration propriété afin de déterminer la valeur maximale valide de le generation paramètre.Use the MaxGeneration property to determine the maximum valid value of the generation parameter.

Pour que le garbage collector considère tous les objets, quel que soit leur génération, utilisez la version de cette méthode qui n’accepte aucun paramètre.To have the garbage collector consider all objects regardless of their generation, use the version of this method that takes no parameters. Pour que le garbage collector récupère les objets selon un GCCollectionMode , utilisez le GC.Collect(Int32, GCCollectionMode) surcharge de méthode.To have the garbage collector reclaim objects based on a GCCollectionMode setting, use the GC.Collect(Int32, GCCollectionMode) method overload.

Voir aussi

Collect(Int32, GCCollectionMode) Collect(Int32, GCCollectionMode) Collect(Int32, GCCollectionMode) 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.

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 Int32 Int32 Int32

Numéro de la génération la plus ancienne devant faire l'objet d'un garbage collection.The number of the oldest generation to be garbage collected.

mode
GCCollectionMode GCCollectionMode GCCollectionMode GCCollectionMode

Valeur d'énumération qui spécifie si le garbage collection est forcé (Default ou Forced) ou optimisé (Optimized).An enumeration value that specifies whether the garbage collection is forced (Default or Forced) or optimized (Optimized).

Exceptions

generation n'est pas valide.generation is not valid.

ou-or- mode ne fait pas partie des valeurs GCCollectionMode.mode is not one of the GCCollectionMode values.

Exemples

L’exemple suivant force un garbage collection pour les objets de génération 2 avec le Optimized paramètre.The following example forces a garbage collection for generation 2 objects with the Optimized setting.

using System;

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

Class Program

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

Remarques

Utilisez le mode paramètre pour spécifier si le garbage collection doit être effectuée immédiatement ou uniquement si le moment est opportun pour récupérer des objets.Use the mode parameter to specify whether garbage collection should occur immediately or only if the time is optimal to reclaim objects. À l’aide de cette méthode ne garantit pas que la mémoire inaccessible dans la génération spécifiée soit libérée.Using this method does not guarantee that all inaccessible memory in the specified generation is reclaimed.

Pour ajuster le niveau d’intrusion du garbage collection pendant des périodes critiques dans votre application, définissez le LatencyMode propriété.To adjust the intrusiveness of garbage collection during critical periods in your application, set the LatencyMode property.

Le garbage collector ne collecte pas les objets avec un numéro de génération supérieur à celui spécifié par le generation paramètre.The garbage collector does not collect objects with a generation number higher than specified by the generation parameter. Utilisez le MaxGeneration propriété afin de déterminer la valeur maximale valide de generation.Use the MaxGeneration property to determine the maximum valid value of generation.

Pour que le garbage collector considère tous les objets, quel que soit leur génération, utilisez la version de cette méthode qui n’accepte aucun paramètre.To have the garbage collector consider all objects regardless of their generation, use the version of this method that takes no parameters.

Pour que le garbage collector récupère des objets jusqu'à une génération spécifiée d’objets, utilisez le GC.Collect(Int32) surcharge de méthode.To have the garbage collector reclaim objects up to a specified generation of objects, use the GC.Collect(Int32) method overload. Lorsque vous spécifiez la génération maximale, tous les objets sont collectés.When you specify the maximum generation, all objects are collected.

Voir aussi

Collect(Int32, GCCollectionMode, Boolean) Collect(Int32, GCCollectionMode, Boolean) Collect(Int32, GCCollectionMode, Boolean) 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.

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 Int32 Int32 Int32

Numéro de la génération la plus ancienne devant faire l'objet d'un garbage collection.The number of the oldest generation to be garbage collected.

mode
GCCollectionMode GCCollectionMode GCCollectionMode GCCollectionMode

Valeur d'énumération qui spécifie si le garbage collection est forcé (Default ou Forced) ou optimisé (Optimized).An enumeration value that specifies whether the garbage collection is forced (Default or Forced) or optimized (Optimized).

blocking
Boolean Boolean Boolean Boolean

true pour effectuer un garbage collection de blocage ; false pour effectuer un garbage collection d'arrière-plan, si possible.true to perform a blocking garbage collection; false to perform a background garbage collection where possible.

Exceptions

generation n'est pas valide.generation is not valid.

ou-or- mode ne fait pas partie des valeurs GCCollectionMode.mode is not one of the GCCollectionMode values.

Remarques

Le tableau suivant résume l’interaction de le mode et blocking paramètres :The following table summarizes the interaction of the mode and blocking parameters:

mode blocking a la valeur true.blocking is true blocking a la valeur false.blocking is false
Forced ou DefaultForced or Default Une collection de blocage est exécutée dès que possible.A blocking collection is performed as soon as 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.If a background collection is in progress and generation is 0 or 1, the Collect(Int32, GCCollectionMode, Boolean) method immediately triggers a blocking collection and returns when the collection is finished. Si une collection d’arrière-plan est en cours et generation est 2, la méthode attend la collection d’arrière-plan est terminée, déclenche une collection de génération 2 blocage et renvoie.If a background collection is in progress and generation is 2, the method waits until the background collection is finished, triggers a blocking generation 2 collection, and then returns. Une collection est exécutée dès que possible.A collection is performed as soon as 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.The Collect(Int32, GCCollectionMode, Boolean) method requests a background collection, but this is not guaranteed; depending on the circumstances, a blocking collection may still be performed. Si une collection d’arrière-plan est déjà en cours, la méthode retourne immédiatement une valeur.If a background collection is already in progress, the method returns immediately.
Optimized Une collecte bloquante peut être exécutée, selon l'état du récupérateur de mémoire et du paramètre generation.A blocking collection may be performed, depending on the state of the garbage collector and the generation parameter. Le Garbage collector tente de fournir des performances optimales.The garbage collector tries to provide optimal performance. Une collection de blocage peut être effectuée, en fonction de l’état du Garbage collector.A collection may be performed, depending on the state of the 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.The Collect(Int32, GCCollectionMode, Boolean) method requests a background collection, but this is not guaranteed; depending on the circumstances, a blocking collection may still be performed. Le Garbage collector tente de fournir des performances optimales.The garbage collector tries to provide optimal performance. Si une collection d’arrière-plan est déjà en cours, la méthode retourne immédiatement une valeur.If a background collection is already in progress, the method returns immediately.

Si un appel à la Collect(Int32, GCCollectionMode, Boolean) méthode effectue une garbage collection de blocage, vous pouvez également compacter le tas d’objets volumineux en définissant le GCSettings.LargeObjectHeapCompactionMode propriété GCLargeObjectHeapCompactionMode.CompactOnce avant d’appeler le Collect (méthode).If a call to the Collect(Int32, GCCollectionMode, Boolean) method performs a full blocking garbage collection, you can also compact the large object heap by setting the GCSettings.LargeObjectHeapCompactionMode property to GCLargeObjectHeapCompactionMode.CompactOnce before calling the Collect method.

Collect(Int32, GCCollectionMode, Boolean, Boolean) Collect(Int32, GCCollectionMode, Boolean, Boolean) Collect(Int32, GCCollectionMode, Boolean, Boolean) 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.

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 Int32 Int32 Int32

Numéro de la génération la plus ancienne devant faire l'objet d'un garbage collection.The number of the oldest generation to be garbage collected.

mode
GCCollectionMode GCCollectionMode GCCollectionMode GCCollectionMode

Valeur d'énumération qui spécifie si le garbage collection est forcé (Default ou Forced) ou optimisé (Optimized).An enumeration value that specifies whether the garbage collection is forced (Default or Forced) or optimized (Optimized).

blocking
Boolean Boolean Boolean Boolean

true pour effectuer un garbage collection de blocage ; false pour effectuer un garbage collection d'arrière-plan, si possible.true to perform a blocking garbage collection; false to perform a background garbage collection where possible.

compacting
Boolean Boolean Boolean Boolean

true pour compacter le tas de petits objets. false pour effectuer un balayage uniquement.true to compact the small object heap; false to sweep only.

Remarques

Si blocking est false, le GC décide s’il faut effectuer un arrière-plan ou une garbage collection de blocage.If blocking is false, the GC decides whether to perform a background or a blocking garbage collection. Si compacting est true, il effectue une garbage collection de blocage.If compacting is true, it performs a blocking garbage collection.

Si compacting est true, le runtime compacte le tas de petits objets (SOH).If compacting is true, the runtime compacts the small object heap (SOH). Le tas d’objets volumineux (LOH) n’est pas compacté, sauf si le GCSettings.LargeObjectHeapCompactionMode propriété est définie sur GCLargeObjectHeapCompactionMode.CompactOnce.The large object heap (LOH) is not compacted unless the GCSettings.LargeObjectHeapCompactionMode property is set to GCLargeObjectHeapCompactionMode.CompactOnce. Notez que cela inclut tous les garbage collections de blocage, pas simplement tous les garbage collections bloquants.Note that this includes all blocking garbage collections, not just full blocking garbage collections.

Vous pouvez appeler la Collect(Int32, GCCollectionMode, Boolean, Boolean) méthode afin de réduire le tas managé la plus petite taille possible, comme l’illustre le fragment de code suivant.You can call the Collect(Int32, GCCollectionMode, Boolean, Boolean) method to reduce the managed heap to the smallest size possible, as the following code fragment illustrates.

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

Spécification true pour le compacting argument garantit une compactage, complète garbage collection de blocage.Specifying true for the compacting argument guarantees a compacting, full blocking garbage collection. Définition de la GCSettings.LargeObjectHeapCompactionMode propriété GCLargeObjectHeapCompactionMode.CompactOnce garantit que le LOH et la déclaration d’intégrité sont compactées.Setting the GCSettings.LargeObjectHeapCompactionMode property to GCLargeObjectHeapCompactionMode.CompactOnce ensures that both the LOH and SOH are compacted.

S’applique à