GC Classe

Referência

Definição

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Origem:: GC.cs

Origem:: GC.cs

Origem:: GC.cs

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Controla o coletor de lixo do sistema, um serviço que recupera automaticamente a memória não utilizada.

public ref class GC abstract sealed

public ref class GC sealed

public static class GC

public sealed class GC

type GC = class

Public Class GC

Public NotInheritable Class GC

Herança: Object
GC

Exemplos

O exemplo a seguir usa vários métodos GC para obter informações de geração e memória sobre um bloco de objetos não utilizados e imprimi-lo no console. Os objetos não utilizados são então coletados e os totais de memória resultantes são exibidos.

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

Para obter mais informações sobre essa API, consulte Comentários sobre a API Complementar para GC.

Propriedades

MaxGeneration

Obtém o número máximo de gerações que o sistema dá suporte atualmente.

Métodos

AddMemoryPressure(Int64)	Informa o runtime de uma alocação grande de memória não gerenciada que deve ser levada em conta durante o agendamento da coleta de lixo.
AllocateArray<T>(Int32, Boolean)	Aloca uma matriz.
AllocateUninitializedArray<T>(Int32, Boolean)	Aloca uma matriz ao ignorar a inicialização zero, se possível.
CancelFullGCNotification()	Cancela o registro de uma notificação de coleta de lixo.
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)	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)	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, 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.
CollectionCount(Int32)	Retorna o número de vezes em que ocorreu a coleta de lixo para a geração de objetos especificada.
EndNoGCRegion()	Encerra o modo de latência de região sem GC.
GetAllocatedBytesForCurrentThread()	Obtém o número total de bytes alocados ao thread atual desde o início de seu tempo de vida.
GetConfigurationVariables()	Obtém as configurações usadas pelo coletor de lixo.
GetGCMemoryInfo()	Obtém informações de memória da coleta de lixo.
GetGCMemoryInfo(GCKind)	Obtém informações de memória da coleta de lixo.
GetGeneration(Object)	Retorna o número de geração atual do objeto especificado.
GetGeneration(WeakReference)	Retorna o número de geração atual do destino de uma referência fraca especificada.
GetTotalAllocatedBytes(Boolean)	Obtém uma contagem dos bytes alocados durante o tempo de vida do processo. O valor retornado não inclui nenhuma alocação nativa.
GetTotalMemory(Boolean)	Recupera o tamanho do heap, excluindo a fragmentação. Por exemplo, se o tamanho total do heap de GC for de 100 mb e a fragmentação, ou seja, o espaço ocupado por objetos livres ocupa 40 mb, essa API relataria 60 mb. Um parâmetro indica se esse método pode esperar um breve intervalo antes de retornar, para permitir que o sistema colete o lixo e finalize os objetos.
GetTotalPauseDuration()	Obtém a quantidade total de tempo pausado no GC desde o início do processo.
KeepAlive(Object)	Referencia o objeto especificado, o que o torna não qualificado para a coleta de lixo, do início da rotina atual ao ponto em que esse método é chamado.
RefreshMemoryLimit()	Instrui o Coletor de Lixo a se reconfigurar detectando os vários limites de memória no sistema.
RegisterForFullGCNotification(Int32, Int32)	Especifica que uma notificação de coleta de lixo deve ser gerada quando as condições favorecerem a coleta de lixo completa e quando a coleção tiver sido concluída.
RegisterNoGCRegionCallback(Int64, Action)	Registra um retorno de chamada a ser invocado quando uma determinada quantidade de memória é alocada na região sem GC.
RemoveMemoryPressure(Int64)	Informa ao runtime que memória não gerenciada foi liberada e não precisa ser considerada ao agendar a coleta de lixo.
ReRegisterForFinalize(Object)	Solicita que o sistema chame o finalizador do objeto especificado para o qual SuppressFinalize(Object) foi chamado anteriormente.
SuppressFinalize(Object)	Solicita que o Common Language Runtime não chame o finalizador do objeto especificado.
TryStartNoGCRegion(Int64)	Tentar desabilitar a coleta de lixo durante a execução de um caminho crítico se uma quantidade especificada de memória estiver disponível.
TryStartNoGCRegion(Int64, Boolean)	Tenta não permitir a coleta de lixo durante a execução de um caminho crítico se houver uma quantidade especificada de memória disponível e controla se o coletor de lixo faz uma coleta de lixo de bloqueio completo se nenhuma memória suficiente estiver inicialmente disponível.
TryStartNoGCRegion(Int64, Int64)	Tentar desabilitar a coleta de lixo durante a execução de um caminho crítico se uma quantidade especificada de memória estiver disponível para o heap de objeto grande e o heap de objeto pequeno.
TryStartNoGCRegion(Int64, Int64, Boolean)	Tenta não permitir a coleta de lixo durante a execução de um caminho crítico se há uma quantidade especificada de memória disponível para o heap de objetos grandes e o heap de objetos pequenos e controla se o coletor de lixo faz uma coleta de lixo de bloqueio completo se nenhuma memória suficiente está inicialmente disponível.
WaitForFullGCApproach()	Retorna o status de uma notificação registrada para determinar se uma coleção completa de lixo de bloqueio realizada pelo Common Language Runtime foi concluída.
WaitForFullGCApproach(Int32)	Retorna, em um período de tempo limite especificado, o status de uma notificação registrada para determinar se uma coleta de lixo de bloqueio completa executada pelo Common Language Runtime é iminente.
WaitForFullGCApproach(TimeSpan)	Retorna, em um período de tempo limite especificado, o status de uma notificação registrada para determinar se uma coleta de lixo de bloqueio completa executada pelo Common Language Runtime é iminente.
WaitForFullGCComplete()	Retorna o status de uma notificação registrada para determinar se uma coleta completa de lixo de bloqueio realizada pelo Common Language Runtime foi concluída.
WaitForFullGCComplete(Int32)	Retorna, em um período de tempo limite especificado, o status de uma notificação registrada para determinar se uma coleta de lixo de bloqueio completo executada pelo Common Language Runtime foi concluída.
WaitForFullGCComplete(TimeSpan)	Retorna o status de uma notificação registrada sobre se uma coleta de lixo de bloqueio foi concluída. Pode esperar indefinidamente por uma coleção completa.
WaitForPendingFinalizers()	Suspende o thread atual até que o thread que está processando a fila de finalizadores tenha esvaziado essa fila.

Aplica-se a

Partilhar via