GC Classe

Riferimento

Definizione

Spazio dei nomi:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Origine:: GC.cs

Origine:: GC.cs

Origine:: GC.cs

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Controlla il Garbage Collector di sistema, un servizio che recupera automaticamente la memoria inutilizzata.

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

Ereditarietà: Object
GC

Esempio

Nell'esempio seguente vengono utilizzati diversi metodi GC per ottenere informazioni sulla generazione e sulla memoria su un blocco di oggetti inutilizzati e stamparli nella console. Gli oggetti inutilizzati vengono quindi raccolti e vengono visualizzati i totali di memoria risultanti.

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

Commenti

Per altre informazioni su questa API, vedere Note sulle API supplementari per GC.

Proprietà

MaxGeneration

Ottiene il numero massimo di generazioni supportate correntemente dal sistema.

Metodi

AddMemoryPressure(Int64)	Informa il runtime di un'allocazione di una grande quantità di memoria non gestita di cui tenere conto durante la pianificazione della procedura di Garbage Collection.
AllocateArray<T>(Int32, Boolean)	Alloca una matrice.
AllocateUninitializedArray<T>(Int32, Boolean)	Alloca una matrice ignorando l'inizializzazione zero, se possibile.
CancelFullGCNotification()	Annulla la registrazione di una notifica di un'operazione di Garbage Collection.
Collect()	Forza un'operazione immediata di Garbage Collection di tutte le generazioni.
Collect(Int32)	Forza un immediato Garbage Collection a partire dalla generazione 0 fino a una determinata generazione.
Collect(Int32, GCCollectionMode)	Forza un'operazione di Garbage Collection dalla generazione 0 a una generazione specificata, in un momento specificato dal valore di GCCollectionMode.
Collect(Int32, GCCollectionMode, Boolean)	Forza un'operazione di Garbage Collection dalla generazione 0 fino a una determinata generazione, in un momento specificato dal valore di GCCollectionMode, con un valore che specifica se la raccolta deve essere bloccante.
Collect(Int32, GCCollectionMode, Boolean, Boolean)	Forza un'operazione di Garbage Collection dalla generazione 0 fino a una determinata generazione, in un momento specificato dal valore di GCCollectionMode, con valori che specificano se la raccolta deve essere bloccante e compattante.
CollectionCount(Int32)	Restituisce il numero di volte che è stata effettuata la procedura di Garbage Collection per la generazione specificata di oggetti.
EndNoGCRegion()	Termina la modalità di eliminazione della latenza delle aree GC.
GetAllocatedBytesForCurrentThread()	Ottiene il numero totale di byte allocati al thread corrente dall'inizio della sua durata.
GetConfigurationVariables()	Ottiene le configurazioni utilizzate dal Garbage Collector.
GetGCMemoryInfo()	Ottiene informazioni sulla memoria di Garbage Collection.
GetGCMemoryInfo(GCKind)	Ottiene informazioni sulla memoria di Garbage Collection.
GetGeneration(Object)	Restituisce il numero corrente di generazione dell'oggetto specificato.
GetGeneration(WeakReference)	Restituisce il numero corrente di generazione della destinazione di uno specifico riferimento debole.
GetTotalAllocatedBytes(Boolean)	Ottiene un conteggio dei byte allocati sulla durata del processo. Il valore restituito non include allocazioni native.
GetTotalMemory(Boolean)	Recupera le dimensioni dell'heap escluse la frammentazione. Ad esempio, se la dimensione totale dell'heap GC è pari a 100 mb e la frammentazione, ad esempio, lo spazio occupato dagli oggetti liberi richiede 40 mb, questa API segnala 60 mb. Un parametro indica se questo metodo può attendere un breve intervallo prima di restituire un risultato per consentire l'esecuzione della procedura di Garbage Collection e la finalizzazione degli oggetti.
GetTotalPauseDuration()	Ottiene la quantità totale di tempo sospesa in GC dall'inizio del processo.
KeepAlive(Object)	Fa riferimento all'oggetto specificato, rendendolo inadatto per il Garbage Collection dall'inizio della routine corrente fino al momento in cui viene chiamato il metodo.
RefreshMemoryLimit()	Indica al Garbage Collector di riconfigurarsi rilevando i vari limiti di memoria nel sistema.
RegisterForFullGCNotification(Int32, Int32)	Specifica che deve essere generata una notifica di un'operazione di Garbage Collection quando le condizioni favoriscono l'operazione di Garbage Collection completa e quando la raccolta è stata completata.
RegisterNoGCRegionCallback(Int64, Action)	Registra un callback da richiamare quando una determinata quantità di memoria viene allocata nell'area GC.
RemoveMemoryPressure(Int64)	Informa il runtime che è stata rilasciata memoria non gestita di cui non occorre più tenere conto durante la pianificazione della procedura di Garbage Collection.
ReRegisterForFinalize(Object)	Richiede che il sistema chiami il finalizzatore per l'oggetto specificato, per il quale è stato precedentemente chiamato il metodo SuppressFinalize(Object).
SuppressFinalize(Object)	Richiede che Common Language Runtime non chiami il finalizzatore per l'oggetto specificato.
TryStartNoGCRegion(Int64)	Prova a impedire l'operazione di Garbage Collection durante l'esecuzione di un percorso critico se è disponibile una quantità specificata di memoria.
TryStartNoGCRegion(Int64, Boolean)	Prova a impedire l'operazione di Garbage Collection durante l'esecuzione di un percorso critico se è disponibile una quantità specificata di memoria; controlla inoltre se il Garbage Collector esegue un'operazione completa di Garbage Collection bloccante se inizialmente non è disponibile memoria sufficiente.
TryStartNoGCRegion(Int64, Int64)	Prova a impedire l'operazione di Garbage Collection durante l'esecuzione di un percorso critico se è disponibile una quantità specificata di memoria per gli heap degli oggetti grandi e degli oggetti piccoli.
TryStartNoGCRegion(Int64, Int64, Boolean)	Prova a impedire l'operazione di Garbage Collection durante l'esecuzione di un percorso critico se è disponibile una quantità specificata di memoria per gli heap degli oggetti grandi e degli oggetti piccoli; controlla inoltre se il Garbage Collector esegue un'operazione completa di Garbage Collection bloccante se inizialmente non è disponibile memoria sufficiente.
WaitForFullGCApproach()	Restituisce lo stato di una notifica registrata per determinare se una procedura completa di Garbage Collection bloccante tramite Common Language Runtime sia imminente.
WaitForFullGCApproach(Int32)	Restituisce, in un periodo di timeout specificato, lo stato di una notifica registrata per determinare se una procedura completa di Garbage Collection bloccante tramite Common Language Runtime sia imminente.
WaitForFullGCApproach(TimeSpan)	Restituisce, in un periodo di timeout specificato, lo stato di una notifica registrata per determinare se una procedura completa di Garbage Collection bloccante tramite Common Language Runtime sia imminente.
WaitForFullGCComplete()	Restituisce lo stato di una notifica registrata per determinare se una procedura completa di Garbage Collection bloccante è stata portata a termine da Common Language Runtime.
WaitForFullGCComplete(Int32)	Restituisce, in un periodo di timeout specificato, lo stato di una notifica registrata per determinare se una procedura completa di Garbage Collection bloccante tramite Common Language Runtime sia stata completata.
WaitForFullGCComplete(TimeSpan)	Restituisce lo stato di una notifica registrata relativa al completamento di un'operazione di Garbage Collection di blocco. Può attendere per un periodo illimitato per una raccolta completa.
WaitForPendingFinalizers()	Sospende il thread corrente fino a quando la coda di finalizzatori non sarà stata svuotata dal thread che la elabora.

Si applica a

Condividi tramite