GC GC GC GC Class

Definizione

Controlla il Garbage Collector di sistema, un servizio che recupera automaticamente la memoria inutilizzata.Controls the system garbage collector, a service that automatically reclaims unused memory.

public ref class GC abstract sealed
public static class GC
type GC = class
Public Class GC
Ereditarietà

Esempi

Nell'esempio seguente vengono utilizzati diversi metodi GC per ottenere informazioni sulla generazione e la memoria relative a un blocco di oggetti inutilizzati e stamparlo nella console.The following example uses several GC methods to get generation and memory information about a block of unused objects and print it to the console. Vengono quindi raccolti gli oggetti inutilizzati e vengono visualizzati i totali di memoria risultanti.The unused objects are then collected, and the resulting memory totals are displayed.

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

Il Garbage Collector è un componente Common Language Runtime che controlla l'allocazione e il rilascio di managed memory.The garbage collector is a common language runtime component that controls the allocation and release of managed memory. I metodi di questa classe hanno effetto quando viene eseguita Garbage Collection su un oggetto e quando vengono rilasciate risorse allocate da un oggetto.The methods in this class influence when garbage collection is performed on an object and when resources allocated by an object are released. Le proprietà di questa classe forniscono informazioni sulla quantità totale di memoria disponibile nel sistema e sulla categoria età, o generazione, della memoria allocata a un oggetto.Properties in this class provide information about the total amount of memory available in the system and the age category, or generation, of memory allocated to an object.

Il Garbage Collector tiene traccia e recupera gli oggetti allocati in managed memory.The garbage collector tracks and reclaims objects allocated in managed memory. Periodicamente, il Garbage Collector esegue Garbage Collection per recuperare la memoria allocata agli oggetti per i quali non sono presenti riferimenti validi.Periodically, the garbage collector performs garbage collection to reclaim memory allocated to objects for which there are no valid references. L'operazione di Garbage Collection viene eseguita automaticamente quando una richiesta di memoria non può essere soddisfatta utilizzando la memoria libera disponibile.Garbage collection happens automatically when a request for memory cannot be satisfied using available free memory. In alternativa, un'applicazione può forzare Garbage Collection usando Collect il metodo.Alternatively, an application can force garbage collection using the Collect method.

L'operazione di Garbage Collection prevede i passaggi seguenti:Garbage collection consists of the following steps:

  1. Il Garbage Collector cerca gli oggetti gestiti a cui viene fatto riferimento nel codice gestito.The garbage collector searches for managed objects that are referenced in managed code.

  2. Il Garbage Collector tenta di finalizzare gli oggetti a cui non si fa riferimento.The garbage collector tries to finalize objects that are not referenced.

  3. Il Garbage Collector libera gli oggetti a cui non viene fatto riferimento e recupera la memoria.The garbage collector frees objects that are not referenced and reclaims their memory.

Questo argomento include le sezioni seguenti:This topic includes the following sections:

Garbage Collector e risorse non gestite The garbage collector and unmanaged resources
Durata e generazioni degli oggetti Object aging and generations
Non consentire Garbage CollectionDisallowing garbage collection

Garbage Collector e risorse non gestiteThe garbage collector and unmanaged resources

Durante una raccolta, il Garbage Collector non libererà un oggetto se trova uno o più riferimenti all'oggetto nel codice gestito.During a collection, the garbage collector will not free an object if it finds one or more references to the object in managed code. Tuttavia, il Garbage Collector non riconosce i riferimenti a un oggetto da codice non gestito e potrebbe liberare oggetti utilizzati esclusivamente nel codice non gestito, a meno che non sia stato esplicitamente impedito.However, the garbage collector does not recognize references to an object from unmanaged code, and might free objects that are being used exclusively in unmanaged code unless explicitly prevented from doing so. Il KeepAlive metodo fornisce un meccanismo che impedisce al Garbage Collector di raccogliere oggetti ancora in uso nel codice non gestito.The KeepAlive method provides a mechanism that prevents the garbage collector from collecting objects that are still in use in unmanaged code.

Oltre alle allocazioni managed memory, le implementazioni del Garbage Collector non mantengono informazioni sulle risorse contenute in un oggetto, ad esempio gli handle di file o le connessioni al database.Aside from managed memory allocations, implementations of the garbage collector do not maintain information about resources held by an object, such as file handles or database connections. Quando un tipo usa risorse non gestite che devono essere rilasciate prima che le istanze del tipo vengano recuperate, il tipo può implementare un finalizzatore.When a type uses unmanaged resources that must be released before instances of the type are reclaimed, the type can implement a finalizer.

Nella maggior parte dei casi, i finalizzatori vengono implementati Object.Finalize eseguendo l'override del metodo; tuttavia C# , C++ i tipi scritti in o implementano i distruttori, i compilatori che trasformano in un override di Object.Finalize.In most cases, finalizers are implemented by overriding the Object.Finalize method; however, types written in C# or C++ implement destructors, which compilers turn into an override of Object.Finalize. Nella maggior parte dei casi, se un oggetto dispone di un finalizzatore, il Garbage Collector lo chiama prima di liberare l'oggetto.In most cases, if an object has a finalizer, the garbage collector calls it prior to freeing the object. Tuttavia, non è necessario che il Garbage Collector chiami finalizzatori in tutte le situazioni. il metodo, ad SuppressFinalize esempio, impedisce in modo esplicito la chiamata del finalizzatore di un oggetto.However, the garbage collector is not required to call finalizers in all situations; for example, the SuppressFinalize method explicitly prevents an object's finalizer from being called. Inoltre, non è necessario che l'Garbage Collector utilizzi un thread specifico per finalizzare gli oggetti oppure garantire l'ordine in cui i finalizzatori vengono chiamati per gli oggetti che fanno riferimento reciprocamente, ma sono altrimenti disponibili per Garbage Collection.Also, the garbage collector is not required to use a specific thread to finalize objects, or guarantee the order in which finalizers are called for objects that reference each other but are otherwise available for garbage collection.

Negli scenari in cui le risorse devono essere rilasciate in un momento specifico, IDisposable le classi possono implementare l' IDisposable.Dispose interfaccia, che contiene il metodo che esegue le attività di pulizia e gestione delle risorse.In scenarios where resources must be released at a specific time, classes can implement the IDisposable interface, which contains the IDisposable.Dispose method that performs resource management and cleanup tasks. Le classi che Dispose implementano devono specificare, come parte del contratto di classe, se e quando gli utenti della classe chiamano il metodo per pulire l'oggetto.Classes that implement Dispose must specify, as part of their class contract, if and when class consumers call the method to clean up the object. Per impostazione predefinita, il Garbage Collector non chiama il Dispose metodo. Tuttavia, le implementazioni Dispose del metodo GC possono chiamare metodi della classe per personalizzare il comportamento di finalizzazione del Garbage Collector.The garbage collector does not, by default, call the Dispose method; however, implementations of the Dispose method can call methods in the GC class to customize the finalization behavior of the garbage collector.

Per ulteriori informazioni sulla finalizzazione degli oggetti e sul modello Dispose, vedere pulizia di risorse non gestite.For more information on object finalization and the dispose pattern, see Cleaning Up Unmanaged Resources.

Durata e generazioni degli oggettiObject aging and generations

Il Garbage Collector nel Common Language Runtime supporta l'invecchiamento degli oggetti tramite generazioni.The garbage collector in the common language runtime supports object aging using generations. Una generazione è un'unità di misura della relativa età degli oggetti in memoria.A generation is a unit of measure of the relative age of objects in memory. Il numero di generazione, o Age, di un oggetto indica la generazione a cui appartiene un oggetto.The generation number, or age, of an object indicates the generation to which an object belongs. Gli oggetti creati più di recente fanno parte di generazioni più recenti e hanno numeri di generazione inferiori rispetto agli oggetti creati in precedenza nel ciclo di vita dell'applicazione.Objects created more recently are part of newer generations, and have lower generation numbers than objects created earlier in the application life cycle. Gli oggetti della generazione più recente si trovano nella generazione 0.Objects in the most recent generation are in generation 0. Questa implementazione del Garbage Collector supporta tre generazioni di oggetti, ovvero le generazioni 0, 1 e 2.This implementation of the garbage collector supports three generations of objects, generations 0, 1, and 2. È possibile recuperare il valore della MaxGeneration proprietà per determinare il numero massimo di generazione supportato dal sistema.You can retrieve the value of the MaxGeneration property to determine the maximum generation number supported by the system.

L'invecchiamento degli oggetti consente alle applicazioni di indirizzare Garbage Collection a un set specifico di generazioni anziché richiedere all'Garbage Collector di valutare tutte le generazioni.Object aging allows applications to target garbage collection at a specific set of generations rather than requiring the garbage collector to evaluate all generations. Gli overload del Collect metodo che includono un generation parametro consentono di specificare la generazione meno recente da sottoposta a Garbage Collection.Overloads of the Collect method that include a generation parameter allow you to specify the oldest generation to be garbage collected.

Non consentire Garbage CollectionDisallowing garbage collection

A partire da .NET Framework 4.6.NET Framework 4.6, il Garbage Collector supporta la modalità nessuna latenza dell'area GC che può essere usata durante l'esecuzione di percorsi critici in cui Garbage Collection può influire negativamente sulle prestazioni di un'app.Starting with the .NET Framework 4.6.NET Framework 4.6, the garbage collector supports a no GC region latency mode that can be used during the execution of critical paths in which garbage collection can adversely affect an app's performance. Per la modalità nessuna latenza dell'area GC è necessario specificare una quantità di memoria che può essere allocata senza interferenze dal Garbage Collector.The no GC region latency mode requires that you specify an amount of memory that can be allocated without interference from the garbage collector. Se il runtime è in grado di allocare tale memoria, il runtime non eseguirà un Garbage Collection durante l'esecuzione del codice nel percorso critico.If the runtime can allocate that memory, the runtime will not perform a garbage collection while code in the critical path is executing.

Si definisce l'inizio del percorso critico di nessuna area GC chiamando uno degli overload di TryStartNoGCRegion.You define the beginning of the critical path of the no GC region by calling one of the overloads of the TryStartNoGCRegion. È possibile specificare la fine del percorso critico chiamando il EndNoGCRegion metodo.You specify the end of its critical path by calling the EndNoGCRegion method.

Non è possibile annidare chiamate TryStartNoGCRegion al metodo ed è necessario chiamare il EndNoGCRegion metodo solo se il runtime non è attualmente in modalità di latenza dell'area GC.You cannot nest calls to the TryStartNoGCRegion method, and you should only call the EndNoGCRegion method if the runtime is currently in no GC region latency mode. In altre parole, non è necessario chiamare TryStartNoGCRegion più volte (dopo la prima chiamata al metodo, le chiamate successive non riusciranno) e non è necessario aspettarsi EndNoGCRegion che le chiamate a abbiano esito positivo TryStartNoGCRegion solo perché la prima chiamata a ha avuto esito positivo.In other words, you should not call TryStartNoGCRegion multiple times (after the first method call, subsequent calls will not succeed), and you should not expect calls to EndNoGCRegion to succeed just because the first call to TryStartNoGCRegion succeeded.

Proprietà

MaxGeneration MaxGeneration MaxGeneration MaxGeneration

Ottiene il numero massimo di generazioni supportate correntemente dal sistema.Gets the maximum number of generations that the system currently supports.

Metodi

AddMemoryPressure(Int64) AddMemoryPressure(Int64) AddMemoryPressure(Int64) 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.Informs the runtime of a large allocation of unmanaged memory that should be taken into account when scheduling garbage collection.

CancelFullGCNotification() CancelFullGCNotification() CancelFullGCNotification() CancelFullGCNotification()

Annulla la registrazione di una notifica di un'operazione di Garbage Collection.Cancels the registration of a garbage collection notification.

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

Forza un'operazione immediata di Garbage Collection di tutte le generazioni.Forces an immediate garbage collection of all generations.

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

Forza un immediato Garbage Collection a partire dalla generazione 0 fino a una determinata generazione.Forces an immediate garbage collection from generation 0 through a specified generation.

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

Forza un'operazione di Garbage Collection dalla generazione 0 a una generazione specificata, in un momento specificato dal valore di 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)

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.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)

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

CollectionCount(Int32) CollectionCount(Int32) CollectionCount(Int32) CollectionCount(Int32)

Restituisce il numero di volte che è stata effettuata la procedura di Garbage Collection per la generazione specificata di oggetti.Returns the number of times garbage collection has occurred for the specified generation of objects.

EndNoGCRegion() EndNoGCRegion() EndNoGCRegion() EndNoGCRegion()

Termina la modalità di eliminazione della latenza delle aree GC.Ends the no GC region latency mode.

GetAllocatedBytesForCurrentThread() GetAllocatedBytesForCurrentThread() GetAllocatedBytesForCurrentThread() GetAllocatedBytesForCurrentThread()

Ottiene il numero totale di byte allocati al thread corrente dall'inizio della sua durata.Gets the total number of bytes allocated to the current thread since the beginning of its lifetime.

GetGCMemoryInfo() GetGCMemoryInfo() GetGCMemoryInfo() GetGCMemoryInfo()

Ottiene informazioni sulla memoria di Garbage Collection.Gets garbage collection memory information.

GetGeneration(Object) GetGeneration(Object) GetGeneration(Object) GetGeneration(Object)

Restituisce il numero corrente di generazione dell'oggetto specificato.Returns the current generation number of the specified object.

GetGeneration(WeakReference) GetGeneration(WeakReference) GetGeneration(WeakReference) GetGeneration(WeakReference)

Restituisce il numero corrente di generazione della destinazione di uno specifico riferimento debole.Returns the current generation number of the target of a specified weak reference.

GetTotalAllocatedBytes(Boolean) GetTotalAllocatedBytes(Boolean) GetTotalAllocatedBytes(Boolean) GetTotalAllocatedBytes(Boolean)

Ottiene un conteggio dei byte allocati sulla durata del processo.Gets a count of the bytes allocated over the lifetime of the process.

GetTotalMemory(Boolean) GetTotalMemory(Boolean) GetTotalMemory(Boolean) GetTotalMemory(Boolean)

Recupera il numero di byte correntemente considerati allocabili.Retrieves the number of bytes currently thought to be allocated. 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.A parameter indicates whether this method can wait a short interval before returning, to allow the system to collect garbage and finalize objects.

KeepAlive(Object) KeepAlive(Object) KeepAlive(Object) 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.References the specified object, which makes it ineligible for garbage collection from the start of the current routine to the point where this method is called.

RegisterForFullGCNotification(Int32, Int32) RegisterForFullGCNotification(Int32, Int32) RegisterForFullGCNotification(Int32, Int32) 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.Specifies that a garbage collection notification should be raised when conditions favor full garbage collection and when the collection has been completed.

RemoveMemoryPressure(Int64) RemoveMemoryPressure(Int64) RemoveMemoryPressure(Int64) 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.Informs the runtime that unmanaged memory has been released and no longer needs to be taken into account when scheduling garbage collection.

ReRegisterForFinalize(Object) ReRegisterForFinalize(Object) ReRegisterForFinalize(Object) ReRegisterForFinalize(Object)

Richiede che il sistema chiami il finalizzatore per l'oggetto specificato, per il quale è stato precedentemente chiamato il metodo SuppressFinalize(Object).Requests that the system call the finalizer for the specified object for which SuppressFinalize(Object) has previously been called.

SuppressFinalize(Object) SuppressFinalize(Object) SuppressFinalize(Object) SuppressFinalize(Object)

Richiede che Common Language Runtime non chiami il finalizzatore per l'oggetto specificato.Requests that the common language runtime not call the finalizer for the specified object.

TryStartNoGCRegion(Int64) TryStartNoGCRegion(Int64) TryStartNoGCRegion(Int64) TryStartNoGCRegion(Int64)

Prova a impedire l'operazione di Garbage Collection durante l'esecuzione di un percorso critico se è disponibile una quantità specificata di memoria.Attempts to disallow garbage collection during the execution of a critical path if a specified amount of memory is available.

TryStartNoGCRegion(Int64, Boolean) TryStartNoGCRegion(Int64, Boolean) TryStartNoGCRegion(Int64, Boolean) 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.Attempts to disallow garbage collection during the execution of a critical path if a specified amount of memory is available, and controls whether the garbage collector does a full blocking garbage collection if not enough memory is initially available.

TryStartNoGCRegion(Int64, Int64) TryStartNoGCRegion(Int64, Int64) TryStartNoGCRegion(Int64, Int64) 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.Attempts to disallow garbage collection during the execution of a critical path if a specified amount of memory is available for the large object heap and the small object heap.

TryStartNoGCRegion(Int64, Int64, Boolean) TryStartNoGCRegion(Int64, Int64, Boolean) TryStartNoGCRegion(Int64, Int64, Boolean) 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.Attempts to disallow garbage collection during the execution of a critical path if a specified amount of memory is available for the large object heap and the small object heap, and controls whether the garbage collector does a full blocking garbage collection if not enough memory is initially available.

WaitForFullGCApproach() WaitForFullGCApproach() WaitForFullGCApproach() WaitForFullGCApproach()

Restituisce lo stato di una notifica registrata per determinare se una procedura completa di Garbage Collection bloccante tramite Common Language Runtime sia imminente.Returns the status of a registered notification for determining whether a full, blocking garbage collection by the common language runtime is imminent.

WaitForFullGCApproach(Int32) WaitForFullGCApproach(Int32) WaitForFullGCApproach(Int32) 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.Returns, in a specified time-out period, the status of a registered notification for determining whether a full, blocking garbage collection by the common language runtime is imminent.

WaitForFullGCComplete() WaitForFullGCComplete() WaitForFullGCComplete() 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.Returns the status of a registered notification for determining whether a full, blocking garbage collection by the common language runtime has completed.

WaitForFullGCComplete(Int32) WaitForFullGCComplete(Int32) WaitForFullGCComplete(Int32) 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.Returns, in a specified time-out period, the status of a registered notification for determining whether a full, blocking garbage collection by common language the runtime has completed.

WaitForPendingFinalizers() WaitForPendingFinalizers() WaitForPendingFinalizers() WaitForPendingFinalizers()

Sospende il thread corrente fino a quando la coda di finalizzatori non sarà stata svuotata dal thread che la elabora.Suspends the current thread until the thread that is processing the queue of finalizers has emptied that queue.

Si applica a

Vedi anche