GC Class

Reference

Definition

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Source:: GC.cs

Source:: GC.cs

Source:: GC.cs

Important

Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.

Controls the system garbage collector, a service that automatically reclaims unused memory.

public ref class GC abstract sealed

public ref class GC sealed

public static class GC

public sealed class GC

type GC = class

Public Class GC

Public NotInheritable Class GC

Inheritance: Object
GC

Examples

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

open System

let maxGarbage = 1000

type MyGCCollectClass() =
    member _.MakeSomeGarbage() =
        for _ = 1 to maxGarbage do
            // Create objects and release them to fill up memory with unused objects.
            Version() |> ignore

[<EntryPoint>]
let main _ =
    let myGCCol = MyGCCollectClass()

    // Determine the maximum number of generations the system
    // garbage collector currently supports.
    printfn $"The highest generation is {GC.MaxGeneration}"

    myGCCol.MakeSomeGarbage()

    // Determine which generation myGCCol object is stored in.
    printfn $"Generation: {GC.GetGeneration myGCCol}"

    // Determine the best available approximation of the number
    // of bytes currently allocated in managed memory.
    printfn $"Total Memory: {GC.GetTotalMemory false}"

    // Perform a collection of generation 0 only.
    GC.Collect 0

    // Determine which generation myGCCol object is stored in.
    printfn $"Generation: {GC.GetGeneration myGCCol}"

    printfn $"Total Memory: {GC.GetTotalMemory false}"

    // Perform a collection of all generations up to and including 2.
    GC.Collect 2

    // Determine which generation myGCCol object is stored in.
    printfn $"Generation: {GC.GetGeneration myGCCol}"
    printfn $"Total Memory: {GC.GetTotalMemory false}"

    0

Namespace GCCollectInt_Example
    Class MyGCCollectClass
        Private maxGarbage As Long = 10000

        Public Shared Sub Main()
            Dim myGCCol As New MyGCCollectClass

            'Determine the maximum number of generations the system
            'garbage collector currently supports.
            Console.WriteLine("The highest generation is {0}", GC.MaxGeneration)

            myGCCol.MakeSomeGarbage()

            'Determine which generation myGCCol object is stored in.
            Console.WriteLine("Generation: {0}", GC.GetGeneration(myGCCol))

            'Determine the best available approximation of the number 
            'of bytes currently allocated in managed memory.
            Console.WriteLine("Total Memory: {0}", GC.GetTotalMemory(False))

            'Perform a collection of generation 0 only.
            GC.Collect(0)

            'Determine which generation myGCCol object is stored in.
            Console.WriteLine("Generation: {0}", GC.GetGeneration(myGCCol))

            Console.WriteLine("Total Memory: {0}", GC.GetTotalMemory(False))

            'Perform a collection of all generations up to and including 2.
            GC.Collect(2)

            'Determine which generation myGCCol object is stored in.
            Console.WriteLine("Generation: {0}", GC.GetGeneration(myGCCol))
            Console.WriteLine("Total Memory: {0}", GC.GetTotalMemory(False))
            Console.Read()

        End Sub


        Sub MakeSomeGarbage()
            Dim vt As Version

            Dim i As Integer
            For i = 0 To maxGarbage - 1
                'Create objects and release them to fill up memory
                'with unused objects.
                vt = New Version
            Next i
        End Sub
    End Class
End Namespace

Remarks

For more information about this API, see Supplemental API remarks for GC.

Properties

MaxGeneration

Gets the maximum number of generations that the system currently supports.

Methods

AddMemoryPressure(Int64)	Informs the runtime of a large allocation of unmanaged memory that should be taken into account when scheduling garbage collection.
AllocateArray<T>(Int32, Boolean)	Allocates an array.
AllocateUninitializedArray<T>(Int32, Boolean)	Allocates an array while skipping zero-initialization, if possible.
CancelFullGCNotification()	Cancels the registration of a garbage collection notification.
Collect()	Forces an immediate garbage collection of all generations.
Collect(Int32)	Forces an immediate garbage collection from generation 0 through a specified generation.
Collect(Int32, GCCollectionMode)	Forces a garbage collection from generation 0 through a specified generation, at a time specified by a GCCollectionMode value.
Collect(Int32, GCCollectionMode, Boolean)	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)	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)	Returns the number of times garbage collection has occurred for the specified generation of objects.
EndNoGCRegion()	Ends the no GC region latency mode.
GetAllocatedBytesForCurrentThread()	Gets the total number of bytes allocated to the current thread since the beginning of its lifetime.
GetConfigurationVariables()	Gets the configurations used by the garbage collector.
GetGCMemoryInfo()	Gets garbage collection memory information.
GetGCMemoryInfo(GCKind)	Gets garbage collection memory information.
GetGeneration(Object)	Returns the current generation number of the specified object.
GetGeneration(WeakReference)	Returns the current generation number of the target of a specified weak reference.
GetTotalAllocatedBytes(Boolean)	Gets a count of the bytes allocated over the lifetime of the process. The returned value does not include any native allocations.
GetTotalMemory(Boolean)	Retrieves the heap size excluding fragmentation. For example if the total GC heap size is 100mb and fragmentation, ie, space taken up by free objects, takes up 40mb, this API would report 60mb. A parameter indicates whether this method can wait a short interval before returning, to allow the system to collect garbage and finalize objects.
GetTotalPauseDuration()	Gets the total amount of time paused in GC since the beginning of the process.
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.
RefreshMemoryLimit()	Instructs the Garbage Collector to reconfigure itself by detecting the various memory limits on the system.
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.
RegisterNoGCRegionCallback(Int64, Action)	Registers a callback to be invoked when a certain amount of memory is allocated in the no GC region.
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)	Requests that the system call the finalizer for the specified object for which SuppressFinalize(Object) has previously been called.
SuppressFinalize(Object)	Requests that the common language runtime not call the finalizer for the specified object.
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)	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)	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)	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()	Returns the status of a registered notification for determining whether a full, blocking garbage collection by the common language runtime is imminent.
WaitForFullGCApproach(Int32)	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.
WaitForFullGCApproach(TimeSpan)	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()	Returns the status of a registered notification for determining whether a full, blocking garbage collection by the common language runtime has completed.
WaitForFullGCComplete(Int32)	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.
WaitForFullGCComplete(TimeSpan)	Returns the status of a registered notification about whether a blocking garbage collection has completed. May wait indefinitely for a full collection.
WaitForPendingFinalizers()	Suspends the current thread until the thread that is processing the queue of finalizers has emptied that queue.

Applies to

Share via