GC.Collect Método

Definição

Força a coleta de lixo.

Sobrecargas

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.

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.

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.

Collect()

Força uma coleta de lixo imediata de todas as gerações.

Collect(Int32)

Força uma coleta de lixo imediata da geração 0 por meio de uma geração especificada.

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.

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

O número da geração mais antiga a ser coletada como lixo.

mode
GCCollectionMode

Um valor de enumeração que especifica se a coleta de lixo é forçada (Default ou Forced) ou otimizada (Optimized).

blocking
Boolean

true para executar uma coleta de lixo de bloqueio; false para executar uma coleta de lixo em segundo plano sempre que possível.

Exceções

generation não é válido.

- ou - mode não é um dos valores GCCollectionMode.

Comentários

A tabela a seguir resume a interação entre os parâmetros e blocking a mode interação:

mode blocking é true blocking é false
Forced ou Default Uma coleção de bloqueio é executada assim que possível. Se uma coleção em segundo plano estiver em andamento e generation for 0 ou 1, o Collect(Int32, GCCollectionMode, Boolean) método disparará imediatamente uma coleção de bloqueio e retornará quando a coleção for concluída. Se uma coleção em segundo plano estiver em andamento e generation for 2, o método aguardará até que a coleção em segundo plano seja concluída, disparará uma coleção de geração 2 de bloqueio e retornará. Uma coleta é executada assim que possível. 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. Se uma coleta em segundo plano já estiver em andamento, o método retornará imediatamente.
Optimized Uma coleta de bloqueio pode ser executada, dependendo do estado do coletor de lixo e do parâmetro generation. O coletor de lixo tenta fornecer um desempenho ideal. Uma coleta pode ser executada, dependendo do estado do coletor de lixo. 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. O coletor de lixo tenta fornecer um desempenho ideal. Se uma coleta em segundo plano já estiver em andamento, o método retornará imediatamente.

Se uma chamada para o Collect(Int32, GCCollectionMode, Boolean) método executar uma coleta de lixo de bloqueio completo, você também poderá compactar o heap de objeto grande definindo a GCSettings.LargeObjectHeapCompactionMode propriedade para GCLargeObjectHeapCompactionMode.CompactOnce antes de chamar o Collect método.

Aplica-se a

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.

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

O número da geração mais antiga a ser coletada como lixo.

mode
GCCollectionMode

Um valor de enumeração que especifica se a coleta de lixo é forçada (Default ou Forced) ou otimizada (Optimized).

Exceções

generation não é válido.

- ou - mode não é um dos valores GCCollectionMode.

Exemplos

O exemplo a seguir força uma coleta de lixo para objetos de geração 2 com a Optimized configuração.

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

Comentários

Use o mode parâmetro para especificar se a coleta de lixo deve ocorrer imediatamente ou somente se o tempo for ideal para recuperar objetos. O uso desse método não garante que toda a memória inacessível na geração especificada seja recuperada.

Para ajustar a intrusão da coleta de lixo durante períodos críticos em seu aplicativo, defina a LatencyMode propriedade.

O coletor de lixo não coleta objetos com um número de geração maior do que o generation especificado pelo parâmetro. Use a MaxGeneration propriedade para determinar o valor máximo válido de generation.

Para que o coletor de lixo considere todos os objetos independentemente de sua geração, use a versão deste método que não usa parâmetros.

Para que o coletor de lixo recupere objetos até uma geração especificada de objetos, use a sobrecarga do GC.Collect(Int32) método. Quando você especifica a geração máxima, todos os objetos são coletados.

Confira também

Aplica-se a

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.

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

O número da geração mais antiga a ser coletada como lixo.

mode
GCCollectionMode

Um valor de enumeração que especifica se a coleta de lixo é forçada (Default ou Forced) ou otimizada (Optimized).

blocking
Boolean

true para executar uma coleta de lixo de bloqueio; false para executar uma coleta de lixo em segundo plano sempre que possível.

compacting
Boolean

true para compactar o heap de objetos pequenos; false para somente limpar.

Comentários

Se blocking for false, o GC decidirá se deseja executar um plano de fundo ou uma coleta de lixo de bloqueio. Se compacting for true, ele executa uma coleta de lixo de bloqueio.

Se compacting for true, o runtime compacta o SOH (heap de objeto pequeno). O LOH (heap de objeto grande) não é compactado, a menos que a GCSettings.LargeObjectHeapCompactionMode propriedade esteja definida como GCLargeObjectHeapCompactionMode.CompactOnce. Observe que isso inclui todos os bloqueios de coletas de lixo, não apenas coletas de lixo de bloqueio total.

Você pode chamar o Collect(Int32, GCCollectionMode, Boolean, Boolean) método para reduzir o heap gerenciado para o menor tamanho possível, como ilustra o fragmento de código a seguir.

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)

Especificar true para o compacting argumento garante uma compactação, coleta de lixo de bloqueio completo. Definir a GCSettings.LargeObjectHeapCompactionMode propriedade para GCLargeObjectHeapCompactionMode.CompactOnce garantir que o LOH e o SOH sejam compactados.

Aplica-se a

Collect()

Força uma coleta de lixo imediata de todas as gerações.

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 coleção em todas as gerações de memória. O código gera vários objetos não utilizados e chama o Collect método para limpá-los da memória.

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

Comentários

Use esse método para tentar recuperar toda a memória inacessível. Ele executa uma coleta de lixo de bloqueio de todas as gerações.

Todos os objetos, independentemente de quanto tempo estiverem na memória, são considerados para coleção; no entanto, os objetos referenciados no código gerenciado não são coletados. Use esse método para forçar o sistema a tentar recuperar a quantidade máxima de memória disponível.

Começando com o .NET Framework 4.5.1, você pode compactar o LOH (heap de objeto grande) definindo a GCSettings.LargeObjectHeapCompactionMode propriedade para GCLargeObjectHeapCompactionMode.CompactOnce antes de chamar o Collect método, como ilustra o exemplo a seguir.

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

Confira também

Aplica-se a

Collect(Int32)

Força uma coleta de lixo imediata da geração 0 por meio de uma geração especificada.

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

O número da geração mais antiga a ser coletada como lixo.

Exceções

generation não é válido.

Exemplos

O exemplo a seguir demonstra como usar o Collect método para executar uma coleção em camadas individuais de memória. O código gera vários objetos não utilizados e chama o Collect método para limpá-los da memória.

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

Comentários

Use este método para tentar recuperar a memória inacessível. No entanto, o uso desse método não garante que toda a memória inacessível na geração especificada seja recuperada.

Se o envelhecimento do objeto for implementado, o coletor de lixo não coletará objetos com um número de geração maior que a geração especificada. Se o envelhecimento do objeto não for implementado, o coletor de lixo considerará todos os objetos durante a coleta de lixo.

Use a MaxGeneration propriedade para determinar o valor máximo válido do generation parâmetro.

Para que o coletor de lixo considere todos os objetos independentemente de sua geração, use a versão deste método que não usa parâmetros. Para que o coletor de lixo recupere objetos com base em uma GCCollectionMode configuração, use a sobrecarga do GC.Collect(Int32, GCCollectionMode) método.

Confira também

Aplica-se a