GC GC GC GC Class

Определение

Управляет системным сборщиком мусора — службой, которая автоматически высвобождает неиспользуемую память.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
Наследование

Примеры

В следующем примере используется несколько методов GC для получения сведений о создании и памяти для блока неиспользуемых объектов и их вывода на консоль.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. Затем будут собраны неиспользуемые объекты, а результирующие итоги памяти отобразятся.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

Комментарии

Сборщик мусора — это компонент среды CLR, управляющий выделением и освобождением управляемой памяти.The garbage collector is a common language runtime component that controls the allocation and release of managed memory. Методы этого класса влияют на то, когда выполняется сборка мусора для объекта и освобождаются ресурсы, выделенные объектом.The methods in this class influence when garbage collection is performed on an object and when resources allocated by an object are released. Свойства в этом классе предоставляют сведения об общем объеме памяти, доступном в системе, а также о категории возраста или формировании памяти, выделенной для объекта.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.

Сборщик мусора отслеживает и освобождает объекты, выделенные в управляемой памяти.The garbage collector tracks and reclaims objects allocated in managed memory. Периодически сборщик мусора выполняет сборку мусора для освобождения памяти, выделенной для объектов, для которых нет допустимых ссылок.Periodically, the garbage collector performs garbage collection to reclaim memory allocated to objects for which there are no valid references. Сборка мусора происходит автоматически, если запрос памяти не может быть удовлетворен с помощью доступной свободной памяти.Garbage collection happens automatically when a request for memory cannot be satisfied using available free memory. Кроме того, приложение может принудительно выполнить сборку мусора с помощью метода Collect.Alternatively, an application can force garbage collection using the Collect method.

Сборка мусора состоит из следующих шагов.Garbage collection consists of the following steps:

  1. Сборщик мусора ищет управляемые объекты, на которые имеются ссылки в управляемом коде.The garbage collector searches for managed objects that are referenced in managed code.

  2. Сборщик мусора пытается завершить объекты, на которые нет ссылок.The garbage collector tries to finalize objects that are not referenced.

  3. Сборщик мусора освобождает объекты, на которые нет ссылок, и освобождает их память.The garbage collector frees objects that are not referenced and reclaims their memory.

Этот раздел включает следующие подразделы:This topic includes the following sections:

Сборщик мусора и неуправляемые ресурсы The garbage collector and unmanaged resources
Устаревание и поколения объектов Object aging and generations
Запрещена сборка мусораDisallowing garbage collection

Сборщик мусора и неуправляемые ресурсыThe garbage collector and unmanaged resources

Во время сбора сборщик мусора не освобождает объект, если находит одну или несколько ссылок на объект в управляемом коде.During a collection, the garbage collector will not free an object if it finds one or more references to the object in managed code. Однако сборщик мусора не распознает ссылки на объект из неуправляемого кода и может освобождать объекты, которые используются исключительно в неуправляемом коде, если это явно не запрещено.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. Метод KeepAlive предоставляет механизм, который предотвращает сбор сборщиком мусора объектов, которые все еще используются в неуправляемом коде.The KeepAlive method provides a mechanism that prevents the garbage collector from collecting objects that are still in use in unmanaged code.

Кроме управляемых выделений памяти, реализации сборщика мусора не поддерживают сведения о ресурсах, удерживаемых объектом, например дескрипторы файлов или подключения к базе данных.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. Если тип использует неуправляемые ресурсы, которые должны быть освобождены до освобождения экземпляров типа, тип может реализовать метод завершения.When a type uses unmanaged resources that must be released before instances of the type are reclaimed, the type can implement a finalizer.

В большинстве случаев методы завершения реализуются путем переопределения метода Object.Finalize; Однако типы, написанные C# в C++ или реализующие деструкторы, переопределяют переопределение 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. В большинстве случаев, если у объекта есть метод завершения, сборщик мусора вызывает его перед освобождением объекта.In most cases, if an object has a finalizer, the garbage collector calls it prior to freeing the object. Однако сборщик мусора не требуется вызывать методы завершения во всех ситуациях. Например, метод SuppressFinalize явно предотвращает вызов метода завершения объекта.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. Кроме того, сборщик мусора не обязан использовать конкретный поток для завершения объектов или гарантировать, что методы завершения вызываются для объектов, ссылающихся друг на друга, но в других случаях доступны для сборки мусора.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.

В сценариях, где ресурсы должны быть освобождены в определенное время, классы могут реализовывать интерфейс IDisposable, который содержит метод IDisposable.Dispose, который выполняет задачи управления ресурсами и очистки.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. Классы, реализующие Dispose, должны указываться в рамках контракта своего класса, если и когда потребители класса вызывают метод для очистки объекта.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. Сборщик мусора по умолчанию не вызывает метод Dispose; Однако реализации метода Dispose могут вызывать методы в классе GC для настройки поведения завершения сборщика мусора.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.

Дополнительные сведения о финализации объектов и шаблоне удаления см. в разделе Очистка неуправляемых ресурсов.For more information on object finalization and the dispose pattern, see Cleaning Up Unmanaged Resources.

Устаревание и поколения объектовObject aging and generations

Сборщик мусора в общеязыковой среде выполнения поддерживает устаревание объектов с помощью поколений.The garbage collector in the common language runtime supports object aging using generations. Поколение — это единица измерения относительного возраста объектов в памяти.A generation is a unit of measure of the relative age of objects in memory. Номер поколения (или возраст) объекта указывает на поколение, которому принадлежит объект.The generation number, or age, of an object indicates the generation to which an object belongs. Недавно созданные объекты являются частью более новых поколений и имеют меньшие номера поколений, чем объекты, созданные ранее в жизненном цикле приложения.Objects created more recently are part of newer generations, and have lower generation numbers than objects created earlier in the application life cycle. Объекты в последнем поколении находятся в поколении 0.Objects in the most recent generation are in generation 0. Эта реализация сборщика мусора поддерживает три поколения объектов, поколения 0, 1 и 2.This implementation of the garbage collector supports three generations of objects, generations 0, 1, and 2. Можно получить значение свойства MaxGeneration, чтобы определить максимальный номер поколения, поддерживаемый системой.You can retrieve the value of the MaxGeneration property to determine the maximum generation number supported by the system.

Устаревание объектов позволяет приложениям нацелиться на сборку мусора в определенном наборе поколений, а не требовать от сборщика мусора оценивать все поколения.Object aging allows applications to target garbage collection at a specific set of generations rather than requiring the garbage collector to evaluate all generations. Перегрузки метода Collect, которые включают параметр generation, позволяют указать самое старое поколение, которое должно быть собрано в мусор.Overloads of the Collect method that include a generation parameter allow you to specify the oldest generation to be garbage collected.

Запрещена сборка мусораDisallowing garbage collection

Начиная с .NET Framework 4.6.NET Framework 4.6 сборщик мусора поддерживает режим задержки без области GC, который можно использовать во время выполнения критических путей, в которых сборка мусора может негативно сказаться на производительности приложения.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. Режим задержки без области GC требует указать объем памяти, который может быть выделен без помех от сборщика мусора.The no GC region latency mode requires that you specify an amount of memory that can be allocated without interference from the garbage collector. Если среда выполнения может выделить эту память, среда выполнения не будет выполнять сборку мусора во время выполнения кода критического пути.If the runtime can allocate that memory, the runtime will not perform a garbage collection while code in the critical path is executing.

Вы определяете начало критического пути к области без GC, вызывая одну из перегрузок TryStartNoGCRegion.You define the beginning of the critical path of the no GC region by calling one of the overloads of the TryStartNoGCRegion. Чтобы указать конец критического пути, вызовите метод EndNoGCRegion.You specify the end of its critical path by calling the EndNoGCRegion method.

Нельзя вкладывать вызовы в метод TryStartNoGCRegion, и следует вызывать метод EndNoGCRegion, если среда выполнения в настоящее время не находится в режиме задержки в области 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. Иными словами, не следует вызывать TryStartNoGCRegion несколько раз (после первого вызова метода, последующие вызовы завершаются неудачно), и не следует рассчитывать на то, что вызовы EndNoGCRegion будут выполняться только потому, что первый вызов TryStartNoGCRegion завершился удачно.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.

Свойства

MaxGeneration MaxGeneration MaxGeneration MaxGeneration

Возвращает наибольшее число поколений, поддерживаемое системой в настоящее время.Gets the maximum number of generations that the system currently supports.

Методы

AddMemoryPressure(Int64) AddMemoryPressure(Int64) AddMemoryPressure(Int64) AddMemoryPressure(Int64)

Информирует среду выполнения о выделении большого объема неуправляемой памяти, которую необходимо учесть при планировании сборки мусора.Informs the runtime of a large allocation of unmanaged memory that should be taken into account when scheduling garbage collection.

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

Отменяет регистрацию уведомления о сборке мусора.Cancels the registration of a garbage collection notification.

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

Принудительно запускает немедленную сборку мусора для всех поколений.Forces an immediate garbage collection of all generations.

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

Принудительно начинает немедленную сборку мусора, начиная с нулевого поколения и вплоть до указанного поколения.Forces an immediate garbage collection from generation 0 through a specified generation.

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

Принудительно запускает немедленную сборку мусора начиная с нулевого поколения и вплоть до указанного поколения в момент времени, заданный значением 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)

Принудительная сборка мусора с поколения 0 до указанного поколения во время, указанное значением GCCollectionMode, со значением, указывающим, должна ли сборка быть блокирующей.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)

Принудительная сборка мусора с поколения 0 до указанного поколения во время, указанное значением GCCollectionMode, со значениями, указывающими, должна ли сборка быть блокирующей и сжимающей.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)

Возвращает количество операций сборки мусора, выполненных для заданного поколения объектов.Returns the number of times garbage collection has occurred for the specified generation of objects.

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

Завершает режим задержки без области сборки мусора.Ends the no GC region latency mode.

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

Возвращает общее число байтов, выделенных для текущего потока с начала времени его существования.Gets the total number of bytes allocated to the current thread since the beginning of its lifetime.

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

Возвращает сведения о памяти при сборке мусора.Gets garbage collection memory information.

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

Возвращает номер текущего поколения указанного объекта.Returns the current generation number of the specified object.

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

Возвращает текущий номер поколения для целевого объекта указанной слабой ссылки.Returns the current generation number of the target of a specified weak reference.

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

Возвращает число байтов, выделенных за время существования процесса.Gets a count of the bytes allocated over the lifetime of the process.

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

Извлекает предполагаемое количество выделенных в данный момент байтов.Retrieves the number of bytes currently thought to be allocated. Параметр указывает, может ли этот метод выдержать короткий интервал времени ожидания перед возвратом, пока система выполняет сборку мусора и завершает объекты.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)

Ссылается на указанный объект, делая его недоступным для сборщика мусора с момента начала текущей процедуры до вызова этого метода.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)

Указывает, что необходимо отправлять уведомления о сборке мусора, когда соблюдены условия для полной сборки мусора и когда завершена сборка.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)

Информирует среду выполнения о том, что неуправляемая память освобождена и ее более не требуется учитывать при планировании сборки мусора.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)

Требует, чтобы система вызвала метод завершения для указанного объекта, для которого ранее был вызван метод 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)

Сообщает среде CLR, что она на не должна вызывать метод завершения для указанного объекта.Requests that the common language runtime not call the finalizer for the specified object.

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

Пытается запретить сборку мусора во время выполнения критического пути, если доступен указанный достаточный объем памяти.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)

Пытается запретить сборку мусора во время выполнения критического пути, если доступен указанный объем памяти, и устанавливает, будет ли выполняться полная блокирующая сборка мусора, если изначально не хватает памяти.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)

Пытается запретить сборку мусора во время выполнения критического пути, если указанный объем памяти доступен для кучи больших объектов и для кучи маленьких объектов.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)

Пытается запретить сборку мусора во время выполнения критического пути, если доступен указанный объем памяти для кучи больших объектов и для кучи маленьких объектов, и устанавливает, будет ли выполняться полная блокирующая сборка мусора, если изначально не хватает памяти.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()

Возвращает состояние зарегистрированного уведомления, чтобы определить, является ли неизбежной полная, блокирующая сборка мусора средой CLR.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)

Возвращает состояние зарегистрированного уведомления в пределах указанного времени ожидания, чтобы определить, является ли неизбежной полная блокировка сборки мусора средой CLR.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()

Возвращает состояние зарегистрированного уведомления, чтобы определить, завершена ли полная блокировка сборки мусора средой CLR.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)

Возвращает состояние зарегистрированного уведомления в пределах указанного времени ожидания, чтобы определить, завершена ли полная блокировка сборки мусора средой CLR.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()

Приостанавливает текущий поток до тех пор, пока поток, обрабатывающий очередь методов завершения, не обработает всю очередь.Suspends the current thread until the thread that is processing the queue of finalizers has emptied that queue.

Применяется к

Дополнительно