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

Definição

Força a coleta de lixo.Forces garbage collection.

Sobrecargas

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

Força uma coleta de lixo imediata de todas as gerações.Forces an immediate garbage collection of all generations.

Collect(Int32) Collect(Int32) Collect(Int32) Collect(Int32)

Força uma coleta de lixo imediata da geração 0 por meio de uma geração especificada.Forces an immediate garbage collection from generation 0 through a specified generation.

Collect(Int32, GCCollectionMode) Collect(Int32, GCCollectionMode) Collect(Int32, GCCollectionMode) Collect(Int32, GCCollectionMode)

Força uma coleta de lixo imediata da geração 0 por meio de uma geração especificada, em uma hora especificada por um valor 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)

Força uma coleta de lixo da geração 0 até uma geração especificada, em um momento especificado por um valor de GCCollectionMode, com um valor que especifica se a coleção deve ser de bloqueio.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)

Força uma coleta de lixo da geração 0 até uma geração especificada, em um momento especificado por um valor de GCCollectionMode, com valores que especificam se a coleta deve ser de bloqueio e compactação.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()

Força uma coleta de lixo imediata de todas as gerações.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 ()

Exemplos

O exemplo a seguir demonstra como usar o Collect método para executar uma coleta em todas as gerações de memória.The following example demonstrates how to use the Collect method to perform a collection on all generations of memory. O código gera um número de objetos não utilizados e, em seguida, chama o Collect método para limpá-los da memória.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

Comentários

Use esse método para tentar recuperar toda a memória que está inacessível.Use this method to try to reclaim all memory that is inaccessible. Ele executa uma coleta de lixo de bloqueio de todas as gerações.It performs a blocking garbage collection of all generations.

Todos os objetos, independentemente de quanto tempo estão na memória, são considerados para uma coleção. No entanto, os objetos que são referenciados no código gerenciado não são coletados.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. Use esse método para forçar o sistema para tentar recuperar a quantidade máxima de memória disponível.Use this method to force the system to try to reclaim the maximum amount of available memory.

Começando com o .NET Framework 4.5.1.NET Framework 4.5.1, você pode compactar o heap de objeto grande (LOH), definindo o GCSettings.LargeObjectHeapCompactionMode propriedade GCLargeObjectHeapCompactionMode.CompactOnce antes de chamar o Collect método, como o exemplo a seguir ilustra.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()      
Veja também

Collect(Int32) Collect(Int32) Collect(Int32) Collect(Int32)

Força uma coleta de lixo imediata da geração 0 por meio de uma geração especificada.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)

Parâmetros

generation
Int32 Int32 Int32 Int32

O número da geração mais antiga a ser coletada como lixo.The number of the oldest generation to be garbage collected.

Exceções

Exemplos

O exemplo a seguir demonstra como usar o Collect método para executar uma coleta em camadas individuais de memória.The following example demonstrates how to use the Collect method to perform a collection on individual layers of memory. O código gera um número de objetos não utilizados e, em seguida, chama o Collect método para limpá-los da memória.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

Comentários

Use esse método para tentar recuperar a memória que está inacessível.Use this method to try to reclaim memory that is inaccessible. No entanto, usando esse método não garante que toda a memória inacessível na geração especificada é recuperada.However, using this method does not guarantee that all inaccessible memory in the specified generation is reclaimed.

Se a classificação por vencimento de objeto for implementada, o coletor de lixo não coletar objetos com um número de geração que é maior do que a geração especificada.If object aging is implemented, the garbage collector does not collect objects with a generation number that is higher than the specified generation. Se o vencimento do objeto não for implementado, o coletor de lixo considera todos os objetos durante a coleta de lixo.If object aging is not implemented, the garbage collector considers all objects during the garbage collection.

Use o MaxGeneration propriedade para determinar o valor válido máximo a generation parâmetro.Use the MaxGeneration property to determine the maximum valid value of the generation parameter.

Para que o coletor de lixo considerar todos os objetos, independentemente de sua geração, use a versão desse método que não usa nenhum parâmetro.To have the garbage collector consider all objects regardless of their generation, use the version of this method that takes no parameters. Para que o coletor de lixo recupera objetos com base em um GCCollectionMode configuração, use o GC.Collect(Int32, GCCollectionMode) sobrecarga de método.To have the garbage collector reclaim objects based on a GCCollectionMode setting, use the GC.Collect(Int32, GCCollectionMode) method overload.

Veja também

Collect(Int32, GCCollectionMode) Collect(Int32, GCCollectionMode) Collect(Int32, GCCollectionMode) Collect(Int32, GCCollectionMode)

Força uma coleta de lixo imediata da geração 0 por meio de uma geração especificada, em uma hora especificada por um valor 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)

Parâmetros

generation
Int32 Int32 Int32 Int32

O número da geração mais antiga a ser coletada como lixo.The number of the oldest generation to be garbage collected.

mode
GCCollectionMode GCCollectionMode GCCollectionMode GCCollectionMode

Um valor de enumeração que especifica se a coleta de lixo é forçada (Default ou Forced) ou otimizada (Optimized).An enumeration value that specifies whether the garbage collection is forced (Default or Forced) or optimized (Optimized).

Exceções

generation não é válido.generation is not valid.

- ou --or- mode não é um dos valores GCCollectionMode.mode is not one of the GCCollectionMode values.

Exemplos

O exemplo a seguir força uma coleta de lixo para objetos da geração 2 com o Optimized configuração.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

Comentários

Use o mode parâmetro para especificar se a coleta de lixo deve ocorrer imediatamente ou somente se o tempo é ideal para recuperar objetos.Use the mode parameter to specify whether garbage collection should occur immediately or only if the time is optimal to reclaim objects. Usando esse método não garante que toda a memória inacessível na geração especificada é recuperada.Using this method does not guarantee that all inaccessible memory in the specified generation is reclaimed.

Para ajustar a intrusão da coleta de lixo durante períodos críticos em seu aplicativo, defina o LatencyMode propriedade.To adjust the intrusiveness of garbage collection during critical periods in your application, set the LatencyMode property.

O coletor de lixo não coletar objetos com um número de geração mais alto do que a especificada pela generation parâmetro.The garbage collector does not collect objects with a generation number higher than specified by the generation parameter. Use o MaxGeneration propriedade para determinar o valor válido máximo generation.Use the MaxGeneration property to determine the maximum valid value of generation.

Para que o coletor de lixo considerar todos os objetos, independentemente de sua geração, use a versão desse método que não usa nenhum parâmetro.To have the garbage collector consider all objects regardless of their generation, use the version of this method that takes no parameters.

Para que o coletor de lixo recupera objetos até uma geração especificada de objetos, use o GC.Collect(Int32) sobrecarga de método.To have the garbage collector reclaim objects up to a specified generation of objects, use the GC.Collect(Int32) method overload. Quando você especifica a geração máxima, todos os objetos são coletados.When you specify the maximum generation, all objects are collected.

Veja também

Collect(Int32, GCCollectionMode, Boolean) Collect(Int32, GCCollectionMode, Boolean) Collect(Int32, GCCollectionMode, Boolean) Collect(Int32, GCCollectionMode, Boolean)

Força uma coleta de lixo da geração 0 até uma geração especificada, em um momento especificado por um valor de GCCollectionMode, com um valor que especifica se a coleção deve ser de bloqueio.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)

Parâmetros

generation
Int32 Int32 Int32 Int32

O número da geração mais antiga a ser coletada como lixo.The number of the oldest generation to be garbage collected.

mode
GCCollectionMode GCCollectionMode GCCollectionMode GCCollectionMode

Um valor de enumeração que especifica se a coleta de lixo é forçada (Default ou Forced) ou otimizada (Optimized).An enumeration value that specifies whether the garbage collection is forced (Default or Forced) or optimized (Optimized).

blocking
Boolean Boolean Boolean Boolean

true para executar uma coleta de lixo de bloqueio; false para executar uma coleta de lixo em segundo plano sempre que possível.true to perform a blocking garbage collection; false to perform a background garbage collection where possible.

Exceções

generation não é válido.generation is not valid.

- ou --or- mode não é um dos valores GCCollectionMode.mode is not one of the GCCollectionMode values.

Comentários

A tabela a seguir resume a interação entre o mode e blocking parâmetros:The following table summarizes the interaction of the mode and blocking parameters:

mode blocking é trueblocking is true blocking é falseblocking is false
Forced ou DefaultForced or Default Uma coleção de bloqueio é executada assim que possível.A blocking collection is performed as soon as possible. Se uma coleta em segundo plano estiver em andamento e generation for 0 ou 1, o Collect(Int32, GCCollectionMode, Boolean) método imediatamente dispara uma coleta de bloqueio e retornará quando a coleção for concluída.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. Se uma coleta em segundo plano estiver em andamento e generation é 2, o método aguardará até que a coleta em segundo plano for concluída, dispara uma coleta de bloqueio de geração 2 e, em seguida, retorna.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. Uma coleta é executada assim que possível.A collection is performed as soon as possible. O método Collect(Int32, GCCollectionMode, Boolean) solicita uma coleta em segundo plano, mas isso não é garantido; dependendo das circunstâncias, uma coleta de bloqueio ainda pode ser executada.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. Se uma coleta em segundo plano já estiver em andamento, o método retornará imediatamente.If a background collection is already in progress, the method returns immediately.
Optimized Uma coleta de bloqueio pode ser executada, dependendo do estado do coletor de lixo e do parâmetro generation.A blocking collection may be performed, depending on the state of the garbage collector and the generation parameter. O coletor de lixo tenta fornecer um desempenho ideal.The garbage collector tries to provide optimal performance. Uma coleta pode ser executada, dependendo do estado do coletor de lixo.A collection may be performed, depending on the state of the garbage collector. O método Collect(Int32, GCCollectionMode, Boolean) solicita uma coleta em segundo plano, mas isso não é garantido; dependendo das circunstâncias, uma coleta de bloqueio ainda pode ser executada.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. O coletor de lixo tenta fornecer um desempenho ideal.The garbage collector tries to provide optimal performance. Se uma coleta em segundo plano já estiver em andamento, o método retornará imediatamente.If a background collection is already in progress, the method returns immediately.

Se uma chamada para o Collect(Int32, GCCollectionMode, Boolean) método executa uma coleta de lixo de bloqueio completo, você também pode compactar o heap de objeto grande, definindo o GCSettings.LargeObjectHeapCompactionMode propriedade GCLargeObjectHeapCompactionMode.CompactOnce antes de chamar o Collect método.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)

Força uma coleta de lixo da geração 0 até uma geração especificada, em um momento especificado por um valor de GCCollectionMode, com valores que especificam se a coleta deve ser de bloqueio e compactação.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)

Parâmetros

generation
Int32 Int32 Int32 Int32

O número da geração mais antiga a ser coletada como lixo.The number of the oldest generation to be garbage collected.

mode
GCCollectionMode GCCollectionMode GCCollectionMode GCCollectionMode

Um valor de enumeração que especifica se a coleta de lixo é forçada (Default ou Forced) ou otimizada (Optimized).An enumeration value that specifies whether the garbage collection is forced (Default or Forced) or optimized (Optimized).

blocking
Boolean Boolean Boolean Boolean

true para executar uma coleta de lixo de bloqueio; false para executar uma coleta de lixo em segundo plano sempre que possível.true to perform a blocking garbage collection; false to perform a background garbage collection where possible.

compacting
Boolean Boolean Boolean Boolean

true para compactar o heap de objetos pequenos; false para somente limpar.true to compact the small object heap; false to sweep only.

Comentários

Se blocking é false, o GC decide se deve executar uma coleta de lixo de bloqueio ou de um plano de fundo.If blocking is false, the GC decides whether to perform a background or a blocking garbage collection. Se compacting é true, ele executa uma coleta de lixo de bloqueio.If compacting is true, it performs a blocking garbage collection.

Se compacting é true, o tempo de execução compacta a heap de objeto pequeno (SOH).If compacting is true, the runtime compacts the small object heap (SOH). O heap de objeto grande (LOH) não é compactado, a menos que o GCSettings.LargeObjectHeapCompactionMode estiver definida como GCLargeObjectHeapCompactionMode.CompactOnce.The large object heap (LOH) is not compacted unless the GCSettings.LargeObjectHeapCompactionMode property is set to GCLargeObjectHeapCompactionMode.CompactOnce. Observe que isso inclui todas as coletas de lixo bloqueio, não apenas completos as coletas de lixo de bloqueio.Note that this includes all blocking garbage collections, not just full blocking garbage collections.

Você pode chamar o Collect(Int32, GCCollectionMode, Boolean, Boolean) método para reduzir o heap gerenciado para o menor valor possível de tamanho, como o fragmento de código a seguir ilustra.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)

Especificando true para o compacting argumento garante uma coleta de lixo completa, compactando bloqueio.Specifying true for the compacting argument guarantees a compacting, full blocking garbage collection. Definindo o GCSettings.LargeObjectHeapCompactionMode propriedade para GCLargeObjectHeapCompactionMode.CompactOnce garante que o LOH e a SOH são compactadas.Setting the GCSettings.LargeObjectHeapCompactionMode property to GCLargeObjectHeapCompactionMode.CompactOnce ensures that both the LOH and SOH are compacted.

Aplica-se a