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

L'esempio seguente usa diversi metodi di catalogo globale per ottenere la generazione e informazioni di memoria su 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. Gli oggetti inutilizzati vengono quindi raccolte e vengono visualizzati i totali della memoria.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();
            }
        }
    }
}
Imports System

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 memoria gestita.The garbage collector is a common language runtime component that controls the allocation and release of managed memory. Fattori che incidono i metodi in questa classe quando garbage collection viene eseguito su un oggetto e quando vengono rilasciate le 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. 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.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 nella memoria gestita.The garbage collector tracks and reclaims objects allocated in managed memory. Periodicamente, il garbage collector esegue garbage collection per recuperare memoria allocata agli oggetti per cui 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. Operazione di Garbage collection viene eseguita automaticamente quando una richiesta per la memoria non può essere soddisfatta usando 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 il Collect (metodo).Alternatively, an application can force garbage collection using the Collect method.

Operazione di Garbage collection è costituita dai passaggi seguenti:Garbage collection consists of the following steps:

  1. Il garbage collector esegue la ricerca per gli oggetti gestiti che fanno riferimento a codice gestito.The garbage collector searches for managed objects that are referenced in managed code.

  2. Il garbage collector tenta di completare gli oggetti che non vengono fatto riferimento.The garbage collector tries to finalize objects that are not referenced.

  3. Il garbage collector libera gli oggetti che non vengono 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:

Il garbage collector e le risorse non gestite The garbage collector and unmanaged resources
Generazioni e la durata dell'oggetto Object aging and generations
Impedisce l'operazione di garbage collectionDisallowing garbage collection

Il garbage collector e le risorse non gestiteThe garbage collector and unmanaged resources

Durante una raccolta, il garbage collector non liberare un oggetto se viene rilevato 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 dal codice non gestito e potrebbe liberare gli oggetti che vengono usati esclusivamente nel codice non gestito se non esplicitamente impedito di farlo.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 gli oggetti che sono 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.

A parte le allocazioni di memoria gestita, le implementazioni del garbage collector non conterranno informazioni sulle risorse mantenute da 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 le risorse non gestite che devono essere rilasciate prima del recupero delle istanze del tipo, 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 mediante l'override di Object.Finalize metodo; tuttavia, tipi scritti in c# o C++ implementano i distruttori, quali i compilatori trasforma 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 ha un finalizzatore, il garbage collector non viene chiamato prima del rilascio dell'oggetto.In most cases, if an object has a finalizer, the garbage collector calls it prior to freeing the object. 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 di chiamata.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, il garbage collector non è necessario usare 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 in caso contrario, sono disponibili per l'operazione di 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, le classi possono implementare il IDisposable interfaccia, che contiene il IDisposable.Dispose metodo che esegue attività di gestione e pulizia di 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 implementano Dispose deve specificare, come parte del contratto, classe se e quando i consumer di 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. 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.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 altre informazioni su alla finalizzazione dell'oggetto e il modello dispose, vedere pulizia di risorse non gestite.For more information on object finalization and the dispose pattern, see Cleaning Up Unmanaged Resources.

Generazioni e la durata dell'oggettoObject aging and generations

Il garbage collector di common language runtime supporta la durata dell'oggetto utilizzando le generazioni.The garbage collector in the common language runtime supports object aging using generations. Una generazione è un'unità di misura della durata degli oggetti in memoria relativa.A generation is a unit of measure of the relative age of objects in memory. Il numero di generazione o età, 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 delle generazioni più recenti e numeri di generazione più bassi rispetto a scorrere gli oggetti creati in precedenza in tutta la durata 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, 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 di numero massimo di generazioni supportato dal sistema.You can retrieve the value of the MaxGeneration property to determine the maximum generation number supported by the system.

La durata dell'oggetto consente alle applicazioni di operazione di garbage collection di destinazione in un set specifico di generazioni, anziché richiedere al 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. Esegue l'overload del Collect metodo che includono un generation parametro consentono di specificare la generazione meno recente per essere sottoposto a garbage collection.Overloads of the Collect method that include a generation parameter allow you to specify the oldest generation to be garbage collected.

Impedisce l'operazione di garbage collectionDisallowing garbage collection

A partire dal .NET Framework 4.6.NET Framework 4.6, il garbage collector supporta una latenza modalità delle aree GC che può essere utilizzata durante l'esecuzione di percorsi critici in garbage collection può influire negativamente sulle prestazioni dell'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. La latenza modalità delle aree GC richiede di 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 può allocare la memoria, il runtime non eseguirà un'operazione di garbage collection durante l'esecuzione di codice in un 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 alcuna area Garbage Collection chiamando uno degli overload del TryStartNoGCRegion.You define the beginning of the critical path of the no GC region by calling one of the overloads of the TryStartNoGCRegion. Si specifica la fine del relativo percorso critico tramite una chiamata di EndNoGCRegion (metodo).You specify the end of its critical path by calling the EndNoGCRegion method.

Non è possibile annidare le chiamate al TryStartNoGCRegion metodo e si deve solo chiamare il EndNoGCRegion metodo, se il runtime è attualmente in alcuna modalità di latenza delle aree 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 chiamare TryStartNoGCRegion più volte (dopo la prima chiamata al metodo, le chiamate successive non avrà esito positivo), e non è necessario attendere le chiamate a EndNoGCRegion abbia esito positivo semplicemente perché la prima chiamata a TryStartNoGCRegion 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.

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.

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