GC Klasse

Definition

Steuert den Garbage Collector des Systems. Das ist ein Dienst, der nicht verwendeten Speicher automatisch freigibt.

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
Vererbung
GC

Beispiele

Im folgenden Beispiel werden mehrere GC-Methoden verwendet, um Generierungs- und Speicherinformationen zu einem Block nicht verwendeter Objekte abzurufen und in die Konsole zu drucken. Die nicht verwendeten Objekte werden dann gesammelt, und die resultierenden Arbeitsspeichersummen werden angezeigt.

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

Hinweise

Weitere Informationen zu dieser API finden Sie unter Zusätzliche API-Hinweise für GC.

Eigenschaften

MaxGeneration

Ruft die maximale Anzahl von Generationen ab, die das System gegenwärtig unterstützt.

Methoden

AddMemoryPressure(Int64)

Informiert die Laufzeit über eine große Belegung von nicht verwaltetem Arbeitsspeicher, der beim Planen der Garbage Collection in Erwägung gezogen werden muss.

AllocateArray<T>(Int32, Boolean)

Ordnet ein Array zu.

AllocateUninitializedArray<T>(Int32, Boolean)

Ordnet ein Array zu, während die Nullinitialisierung nach Möglichkeit übersprungen wird.

CancelFullGCNotification()

Bricht die Registrierung einer Garbage Collection-Benachrichtigung ab.

Collect()

Erzwingt eine sofortige Garbage Collection für alle Generationen.

Collect(Int32)

Erzwingt eine sofortige Garbage Collection von Generation 0 (null) bis zu einer angegebenen Generation.

Collect(Int32, GCCollectionMode)

Erzwingt eine Garbage Collection von Generation 0 (null) bis zu einer angegebenen Generation zu einem durch einen GCCollectionMode-Wert angegebenen Zeitpunkt.

Collect(Int32, GCCollectionMode, Boolean)

Erzwingt eine Garbage Collection von Generation 0 (null) bis zu einer angegebenen Generation, angegeben durch jeweils einen GCCollectionMode-Wert und mit einem Wert, der angibt, ob die Auflistung blockieren soll.

Collect(Int32, GCCollectionMode, Boolean, Boolean)

Erzwingt eine Garbage Collection von Generation 0 (null) bis zu einer angegebenen Generation, angegeben durch jeweils einen GCCollectionMode-Wert und mit Werten, die angeben, ob die Auflistung blockieren und komprimieren soll.

CollectionCount(Int32)

Gib die Anzahl zurück, wie oft die Garbage Collection für die angegebene Objektgeneration stattgefunden hat.

EndNoGCRegion()

Beendet den Latenzmodus ohne GC-Region.

GetAllocatedBytesForCurrentThread()

Ruft die Gesamtzahl der Bytes ab, die dem aktuellen Thread seit Beginn seiner Lebensdauer zugeordnet wurden.

GetConfigurationVariables()

Ruft die vom Garbage Collector verwendeten Konfigurationen ab.

GetGCMemoryInfo()

Ruft Arbeitsspeicherinformationen für die Garbage Collection ab.

GetGCMemoryInfo(GCKind)

Ruft Arbeitsspeicherinformationen für die Garbage Collection ab.

GetGeneration(Object)

Gibt die aktuelle Generationszahl des angegebenen Objekts zurück.

GetGeneration(WeakReference)

Gibt die aktuelle Generationszahl für das Ziel eines angegebenen schwachen Verweises zurück.

GetTotalAllocatedBytes(Boolean)

Ruft die Anzahl der Bytes ab, die über die Lebensdauer des Prozesses zugeordnet wurden. Der zurückgegebene Wert enthält keine nativen Zuordnungen.

GetTotalMemory(Boolean)

Ruft die Heapgröße ohne Fragmentierung ab. Wenn die Gesamtgröße des GC-Heaps beispielsweise 100 MB beträgt und die Fragmentierung, d. h. der von freien Objekten belegte Speicherplatz, 40 MB beansprucht, würde diese API 60 MB melden. Ein Parameter gibt an, ob diese Methode vor der Rückgabe eine kurze Zeit warten kann, damit das System die Garbage Collection durchführen und Objekte finalisieren kann.

GetTotalPauseDuration()

Ruft die Gesamtdauer ab, die seit Beginn des Prozesses in GC angehalten wurde.

KeepAlive(Object)

Verweist auf das angegebene Objekt und nimmt es von Beginn der aktuellen Routine bis zum Zeitpunkt des Aufrufs dieser Methode von der Garbage Collection aus.

RefreshMemoryLimit()

Weist den Garbage Collector an, sich selbst neu zu konfigurieren, indem die verschiedenen Speichergrenzwerte im System erkannt werden.

RegisterForFullGCNotification(Int32, Int32)

Gibt an, dass eine Garbage Collection-Benachrichtigung ausgelöst werden soll, wenn eine vollständige Garbage Collection durch die Bedingungen begünstigt wird und wenn die Garbage Collection abgeschlossen wurde.

RegisterNoGCRegionCallback(Int64, Action)

Registriert einen Rückruf, der aufgerufen wird, wenn eine bestimmte Menge an Arbeitsspeicher in der Region ohne GC zugewiesen ist.

RemoveMemoryPressure(Int64)

Informiert die Laufzeit, dass nicht verwalteter Arbeitsspeicher freigegeben wurde und beim Planen der Garbage Collection nicht mehr berücksichtigt werden muss.

ReRegisterForFinalize(Object)

Fordert beim System den Aufruf des Finalizers für das angegebene Objekt an, für das zuvor SuppressFinalize(Object) aufgerufen wurde.

SuppressFinalize(Object)

Fordert die Common Language Runtime auf, den Finalizer für das angegebene Objekt nicht aufzurufen.

TryStartNoGCRegion(Int64)

Versucht, Garbage Collection während der Ausführung eines kritischen Pfads zu unterbinden, wenn eine bestimmte Arbeitsspeichermenge verfügbar ist.

TryStartNoGCRegion(Int64, Boolean)

Versucht, Garbage Collection während der Ausführung eines kritischen Pfads zu unterbinden, wenn eine bestimmte Arbeitsspeichermenge verfügbar ist, und steuert die Ausführung einer vollständigen blockierenden Garbage Collection durch den Garbage Collector, wenn nicht genügend Arbeitsspeicher verfügbar ist.

TryStartNoGCRegion(Int64, Int64)

Versucht, Garbage Collection während der Ausführung eines kritischen Pfads zu unterbinden, wenn eine bestimmte Arbeitsspeichermenge für den großen und den kleinen Objektheap verfügbar ist.

TryStartNoGCRegion(Int64, Int64, Boolean)

Versucht, Garbage Collection während der Ausführung eines kritischen Pfads zu unterbinden, wenn eine bestimmte Arbeitsspeichermenge für den großen und den kleinen Objektheap verfügbar ist, und steuert die Ausführung einer vollständigen blockierenden Garbage Collection durch den Garbage Collector, wenn nicht genügend Arbeitsspeicher verfügbar ist.

WaitForFullGCApproach()

Gibt den Status einer registrierten Benachrichtigung zurück, um zu bestimmen, ob eine vollständige blockierende Garbage Collection durch die Common Language Runtime bevorsteht.

WaitForFullGCApproach(Int32)

Gibt innerhalb einer angegebenen Timeoutspanne den Status einer registrierten Benachrichtigung zurück, um zu bestimmen, ob eine vollständige blockierende Garbage Collection durch die Common Language Runtime bevorsteht.

WaitForFullGCApproach(TimeSpan)

Gibt innerhalb einer angegebenen Timeoutspanne den Status einer registrierten Benachrichtigung zurück, um zu bestimmen, ob eine vollständige blockierende Garbage Collection durch die Common Language Runtime bevorsteht.

WaitForFullGCComplete()

Gibt den Status einer registrierten Benachrichtigung zurück, um zu bestimmen, ob eine vollständige blockierende Garbage Collection durch die Common Language Runtime abgeschlossen wurde.

WaitForFullGCComplete(Int32)

Gibt innerhalb einer angegebenen Timeoutspanne den Status einer registrierten Benachrichtigung zurück, um zu bestimmen, ob eine vollständige blockierende Garbage Collection durch die Common Language Runtime abgeschlossen wurde.

WaitForFullGCComplete(TimeSpan)

Gibt die status einer registrierten Benachrichtigung zurück, ob eine blockierende Garbage Collection abgeschlossen wurde. Kann unbegrenzt auf eine vollständige Sammlung warten.

WaitForPendingFinalizers()

Hält den aktuellen Thread so lange an, bis der Thread, der die Finalizerwarteschlange verarbeitet, diese Warteschlange geleert hat.

Gilt für:

Weitere Informationen