Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Classe GC

 

Data di pubblicazione: novembre 2016

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

Spazio dei nomi:   System
Assembly:  mscorlib (in mscorlib.dll)


public static class GC

NomeDescrizione
System_CAPS_pubpropertySystem_CAPS_staticMaxGeneration

Ottiene il numero massimo di generazioni supportate correntemente dal sistema.

NomeDescrizione
System_CAPS_pubmethodSystem_CAPS_staticAddMemoryPressure(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.

System_CAPS_pubmethodSystem_CAPS_staticCancelFullGCNotification()

Annulla la registrazione di una notifica di un'operazione di Garbage Collection.

System_CAPS_pubmethodSystem_CAPS_staticCollect()

Forza un'operazione immediata di Garbage Collection di tutte le generazioni.

System_CAPS_pubmethodSystem_CAPS_staticCollect(Int32)

Forza un immediato Garbage Collection a partire dalla generazione 0 fino a una determinata generazione.

System_CAPS_pubmethodSystem_CAPS_staticCollect(Int32, GCCollectionMode)

Forza un'operazione di Garbage Collection dalla generazione 0 a una generazione specificata, in un momento specificato dal valore di GCCollectionMode.

System_CAPS_pubmethodSystem_CAPS_staticCollect(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.

System_CAPS_pubmethodSystem_CAPS_staticCollect(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.

System_CAPS_pubmethodSystem_CAPS_staticCollectionCount(Int32)

Restituisce il numero di volte che è stata effettuata la procedura di Garbage Collection per la generazione specificata di oggetti.

System_CAPS_pubmethodSystem_CAPS_staticEndNoGCRegion()

Termina la modalità di eliminazione della latenza delle aree GC.

System_CAPS_pubmethodSystem_CAPS_staticGetGeneration(Object)

Restituisce il numero corrente di generazione dell'oggetto specificato.

System_CAPS_pubmethodSystem_CAPS_staticGetGeneration(WeakReference)

Restituisce il numero corrente di generazione della destinazione di uno specifico riferimento debole.

System_CAPS_pubmethodSystem_CAPS_staticGetTotalMemory(Boolean)

Recupera il numero di byte correntemente considerati allocabili. 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.

System_CAPS_pubmethodSystem_CAPS_staticKeepAlive(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.

System_CAPS_pubmethodSystem_CAPS_staticRegisterForFullGCNotification(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.

System_CAPS_pubmethodSystem_CAPS_staticRemoveMemoryPressure(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.

System_CAPS_pubmethodSystem_CAPS_staticReRegisterForFinalize(Object)

Richiede che il sistema chiami il finalizzatore per l'oggetto specificato, per il quale è stato precedentemente chiamato il metodo SuppressFinalize.

System_CAPS_pubmethodSystem_CAPS_staticSuppressFinalize(Object)

Richiede che Common Language Runtime non chiami il finalizzatore per l'oggetto specificato.

System_CAPS_pubmethodSystem_CAPS_staticTryStartNoGCRegion(Int64)

Prova a impedire l'operazione di Garbage Collection durante l'esecuzione di un percorso critico se è disponibile una quantità specificata di memoria.

System_CAPS_pubmethodSystem_CAPS_staticTryStartNoGCRegion(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.

System_CAPS_pubmethodSystem_CAPS_staticTryStartNoGCRegion(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.

System_CAPS_pubmethodSystem_CAPS_staticTryStartNoGCRegion(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.

System_CAPS_pubmethodSystem_CAPS_staticWaitForFullGCApproach()

Restituisce lo stato di una notifica registrata per determinare se una procedura completa di Garbage Collection bloccante tramite Common Language Runtime sia imminente.

System_CAPS_pubmethodSystem_CAPS_staticWaitForFullGCApproach(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.

System_CAPS_pubmethodSystem_CAPS_staticWaitForFullGCComplete()

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.

System_CAPS_pubmethodSystem_CAPS_staticWaitForFullGCComplete(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.

System_CAPS_pubmethodSystem_CAPS_staticWaitForPendingFinalizers()

Sospende il thread corrente fino a quando la coda di finalizzatori non sarà stata svuotata dal thread che la elabora.

Il garbage collector non è un componente di common language runtime che controlla l'allocazione e il rilascio di memoria gestita. I metodi in questa classe determinano quando l'operazione di garbage collection viene eseguita su un oggetto e quando vengono rilasciate le risorse allocate da un oggetto. Proprietà di questa classe forniscono informazioni sulla quantità totale di memoria disponibile nel sistema e la categoria di età o generazione, della memoria allocata a un oggetto.

Il garbage collector tiene traccia e recupera gli oggetti allocati nella memoria gestita. Periodicamente, il garbage collector esegue garbage collection per recuperare la memoria allocata agli oggetti per cui non sono presenti riferimenti validi. Operazione di Garbage collection viene eseguita automaticamente quando una richiesta di memoria non può essere soddisfatti mediante memoria libera disponibile. In alternativa, un'applicazione può forzare garbage collection con il Collect metodo.

Operazione di Garbage collection è costituito dai passaggi seguenti:

  1. Il garbage collector esegue la ricerca di oggetti gestiti a cui fa riferimento nel codice gestito.

  2. Il garbage collector tenta di completare gli oggetti che non fa riferimento.

  3. Il garbage collector libera gli oggetti che non fa riferimento e recupera la memoria.

Questo argomento include le sezioni seguenti:

Il garbage collector e le risorse non gestite
Generazioni e la durata dell'oggetto
Impedisce l'operazione di garbage collection

Durante una raccolta, il garbage collector non libera un oggetto se vengono rilevati uno o più riferimenti all'oggetto nel codice gestito. Tuttavia, il garbage collector non riconosce i riferimenti a un oggetto dal codice non gestito e potrebbe liberare gli oggetti che vengono utilizzati esclusivamente nel codice non gestito a meno che non esplicitamente impedito di farlo. Il KeepAlive metodo fornisce un meccanismo che impedisce al garbage collector di raccogliere gli oggetti che sono ancora in uso nel codice non gestito.

A parte le allocazioni di memoria gestita, le implementazioni del garbage collector non mantengono le informazioni sulle risorse occupate da un oggetto, ad esempio gli handle di file o le connessioni al database. Quando un tipo utilizza le risorse non gestite che devono essere rilasciate prima del recupero delle istanze del tipo, il tipo può implementare un finalizzatore.

Nella maggior parte dei casi, i finalizzatori vengono implementati eseguendo l'override di Object.Finalize metodo; tuttavia, i tipi scritti in c# o C++ implementano distruttori, quali compilatori in un override di Object.Finalize. Nella maggior parte dei casi, se un oggetto ha un finalizzatore, il garbage collector viene chiamato prima di liberare l'oggetto. Tuttavia, il garbage collector non è necessario chiamare i finalizzatori in tutte le situazioni. ad esempio, il SuppressFinalize metodo impedisce in modo esplicito un finalizzatore dell'oggetto venga chiamato. Inoltre, il garbage collector non è necessario utilizzare un thread specifico per completare gli oggetti o garantisce l'ordine in cui vengono chiamati i finalizzatori per gli oggetti che fanno riferimento a altro, ma sono comunque disponibili per l'operazione di garbage collection.

In scenari in cui le risorse devono essere rilasciate in un momento specifico, possono implementare le classi di IDisposable interfaccia, che contiene il IDisposable.Dispose metodo che esegue attività di gestione e la pulizia delle risorse. Le classi che implementano Dispose devono specificare, come parte del contratto classe, se e quando i consumer di classe chiamano il metodo per pulire l'oggetto. Il garbage collector non, per impostazione predefinita, chiama il Dispose metodo; tuttavia, le implementazioni del Dispose metodo può chiamare metodi GC classe per personalizzare il comportamento di finalizzazione del garbage collector.

Per ulteriori informazioni sul completamento di un oggetto e il modello dispose, vedere Cleaning Up Unmanaged Resources.

Il garbage collector di common language runtime supporta la durata dell'oggetto utilizzando le generazioni. Una generazione è un'unità di misura della durata relativa degli oggetti in memoria. Il numero di generazione, o l'età, di un oggetto indica la generazione a cui appartiene l'oggetto. Gli oggetti creati più recente fanno parte delle generazioni più recenti e numeri di generazione più bassi rispetto a scorrere gli oggetti creati in precedenza in tutta la durata dell'applicazione. Gli oggetti della generazione più recente si trovano nella generazione 0. Questa implementazione del garbage collector supporta tre generazioni di oggetti, le generazioni 0, 1 e 2. È possibile recuperare il valore di MaxGeneration proprietà per determinare il numero massimo di generazione supportato dal sistema.

La durata dell'oggetto consente alle applicazioni di operazione di garbage collection di destinazione in un set specifico di generazioni piuttosto che il garbage collector valutare tutte le generazioni. Esegue l'overload di Collect metodo che includono un generation parametro consente di specificare la generazione meno recente per essere sottoposto a garbage collection.

A partire dal .NET Framework 4.6, il garbage collector supporta una modalità aree GC latenza che può essere utilizzata durante l'esecuzione di percorsi critici in cui garbage raccolta può influire negativamente sulle prestazioni di un'app. Nessuna modalità di latenza delle aree di GC è necessario specificare una quantità di memoria da allocare senza interferenze del garbage collector. Se il runtime può allocare la memoria, il runtime non eseguire un'operazione di garbage collection durante l'esecuzione di codice in un percorso critico.

Si definisce l'inizio del percorso critico dell'area non GC chiamando uno degli overload di TryStartNoGCRegion. Specificare la fine del percorso critico chiamando il EndNoGCRegion metodo.

Non è possibile annidare le chiamate al TryStartNoGCRegion metodo e si devono chiamare solo il EndNoGCRegion metodo se il runtime è attualmente in alcuna modalità di latenza delle aree GC. In altre parole, non è necessario chiamare TryStartNoGCRegion più volte (dopo la prima chiamata di metodo, le chiamate successive non avrà esito positivo), e non è necessario attendere le chiamate a EndNoGCRegion abbia esito positivo solo perché la prima chiamata a TryStartNoGCRegion ha avuto esito positivo.

Nell'esempio seguente utilizza diversi metodi di catalogo globale per ottenere la generazione di informazioni sulla memoria relative a un blocco di oggetti inutilizzati e stamparlo nella console. Gli oggetti inutilizzati vengono quindi raccolti e vengono visualizzati i totali della memoria.

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

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 1.1
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.0
Windows Phone
Disponibile da 8.1

I membri statici pubblici ( Condiviso in Visual Basic) di questo tipo è thread safe. Non tutti i membri di istanza sono garantiti come thread safe.

Torna all'inizio
Mostra: