GC Klasse

Referenz

Definition

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

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: Object
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 Speichersummen 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

Der Garbage Collector ist eine komponente der allgemeinen Sprachlaufzeit, die die Zuordnung und Freigabe des verwalteten Arbeitsspeichers steuert. Die Methoden in dieser Klasse beeinflussen, wann die Garbage Collection für ein Objekt ausgeführt wird und wann Ressourcen freigegeben werden, die einem Objekt zugeordnet sind. Eigenschaften in dieser Klasse enthalten Informationen über die Gesamtmenge des Arbeitsspeichers, der im System und in der Alterskategorie oder der Generation des Speichers vorhanden ist, der einem Objekt zugeordnet ist.

Der Garbage Collector verfolgt und ruft Objekte zurück, die im verwalteten Speicher zugeordnet sind. In regelmäßigen Abständen führt der Garbage Collector Garbage Collection aus, um den für Objekte zugewiesenen Speicher zurückzugeben, für die keine gültigen Verweise vorhanden sind. Garbage Collection geschieht automatisch, wenn eine Anforderung für den Arbeitsspeicher nicht mit dem verfügbaren freien Arbeitsspeicher erfüllt werden kann. Alternativ kann eine Anwendung die Garbage Collection mithilfe der Collect Methode erzwingen.

Garbage Collection besteht aus den folgenden Schritten:

Der Garbage Collector sucht nach verwalteten Objekten, auf die im verwalteten Code verwiesen wird.
Der Garbage Collector versucht, Objekte abzuschließen, auf die nicht verwiesen wird.
Der Garbage Collector gibt Objekte frei, auf die nicht verwiesen wird und deren Speicher zurückgibt.

Dieses Thema enthält die folgenden Abschnitte:

Die Garbage Collector- und nicht verwalteten Ressourcen
Objektalterung und Generationen
Verwesen der Garbage Collection

Die Garbage Collector- und nicht verwalteten Ressourcen

Während einer Auflistung wird vom Garbage Collector kein Objekt freigegeben, wenn ein oder mehrere Verweise auf das Objekt im verwalteten Code gefunden werden. Der Garbage Collector erkennt jedoch keine Verweise auf ein Objekt aus nicht verwaltetem Code und kann Objekte freigeben, die ausschließlich im nicht verwalteten Code verwendet werden, es sei denn, dies wurde explizit verhindert. Die KeepAlive Methode stellt einen Mechanismus bereit, der verhindert, dass der Garbage Collector Objekte sammelt, die weiterhin im nicht verwalteten Code verwendet werden.

Abgesehen von verwalteten Speicherzuweisungen erhalten Implementierungen des Garbage Collector keine Informationen zu Ressourcen, die von einem Objekt gespeichert werden, z. B. Dateihandles oder Datenbankverbindungen. Wenn ein Typ nicht verwaltete Ressourcen verwendet, die freigegeben werden müssen, bevor Instanzen des Typs erneut abgerufen werden, kann der Typ einen Finalizer implementieren.

In den meisten Fällen werden Finalizer implementiert, indem die Methode außer Kraft gesetzt wird. Typen, die Object.Finalize in C# oder C++ geschrieben wurden, implementieren Destruktoren, die Compiler in eine Außerkraftsetzung Object.Finalizeumwandeln. Wenn ein Objekt einen Finalizer aufweist, ruft der Garbage Collector es in den meisten Fällen vor dem Freigeben des Objekts auf. Der Garbage Collector ist jedoch nicht erforderlich, um Finalizer in allen Situationen aufzurufen; Beispielsweise verhindert die SuppressFinalize Methode explizit, dass der Finalizer eines Objekts aufgerufen wird. Außerdem ist der Garbage Collector nicht erforderlich, um objekte mit einem bestimmten Thread abzuschließen, oder die Reihenfolge zu garantieren, in der Finalizer für Objekte aufgerufen werden, die auf einander verweisen, aber sonst für die Garbage Collection verfügbar sind.

In Szenarien, in denen Ressourcen zu einem bestimmten Zeitpunkt freigegeben werden müssen, können Klassen die IDisposable Schnittstelle implementieren, die die Methode enthält, die Ressourcenverwaltungs IDisposable.Dispose - und Bereinigungsaufgaben ausführt. Klassen, die implementieren Dispose , müssen als Teil ihres Klassenvertrags angeben, ob und wann Klassenkunden die Methode aufrufen, um das Objekt zu bereinigen. Der Garbage Collector ruft die Dispose Methode standardmäßig nicht auf. Implementierungen der Methode können jedoch Methoden in der Dispose GC Klasse aufrufen, um das Endisierungsverhalten des Garbage Collector anzupassen.

Weitere Informationen zur Objektdefinierung und zum Entsorgungsmuster finden Sie unter Bereinigen nicht verwalteter Ressourcen.

Objektalterung und Generationen

Der Garbage Collector in der allgemeinen Sprachlaufzeit unterstützt die Objektalterung mithilfe von Generationen. Eine Generation ist eine Maßeinheit des relativen Alters von Objekten im Arbeitsspeicher. Die Generationsnummer oder das Alter eines Objekts gibt die Generation an, zu der ein Objekt gehört. Objekte, die kürzlich erstellt wurden, sind Teil neuerer Generationen und verfügen über niedrigere Generationszahlen als Objekte, die früher im Anwendungslebenszyklus erstellt wurden. Objekte in der neuesten Generation befinden sich in Generation 0. Diese Implementierung des Garbage Collector unterstützt drei Generationen von Objekten, Generationen 0, 1 und 2. Sie können den Wert der MaxGeneration Eigenschaft abrufen, um die vom System unterstützte maximale Generationsnummer zu ermitteln.

Objektalterung ermöglicht Anwendungen das Ziel der Garbage Collection auf eine bestimmte Reihe von Generationen, anstatt dass der Garbage Collector alle Generationen auswerten muss. Überladungen der Collect Methode, die einen generation Parameter enthalten, ermöglichen es Ihnen, die älteste Generation anzugeben, die gesammelt werden soll.

Verwesen der Garbage Collection

Ab dem .NET Framework 4.6 unterstützt der Garbage Collector einen GC-Bereichslatenzmodus, der während der Ausführung kritischer Pfade verwendet werden kann, in denen die Garbage Collection die Leistung einer App negativ beeinflussen kann. Der Latenzmodus für GC-Regionen erfordert, dass Sie einen Arbeitsspeicher angeben, der ohne Störungen vom Garbage Collector zugewiesen werden kann. Wenn die Laufzeit diesen Arbeitsspeicher zuordnen kann, führt die Laufzeit keine Garbage Collection aus, während Code im kritischen Pfad ausgeführt wird.

Sie definieren den Anfang des kritischen Pfads der no GC-Region, indem Sie eine der Überladungen der TryStartNoGCRegion. Sie geben das Ende des kritischen Pfads an, indem Sie die EndNoGCRegion Methode aufrufen.

Sie können keine Aufrufe der TryStartNoGCRegion Methode verschachteln, und Sie sollten die EndNoGCRegion Methode nur aufrufen, wenn sich die Laufzeit derzeit nicht im GC-Bereichslatenzmodus befindet. Mit anderen Worten, Sie sollten nicht mehrmals aufrufen TryStartNoGCRegion (nach dem ersten Methodenaufruf, nachfolgende Aufrufe werden nicht erfolgreich ausgeführt), und Sie sollten nicht erwarten, dass Aufrufe EndNoGCRegion erfolgreich sind, nur weil der erste Aufruf erfolgreich war TryStartNoGCRegion .

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 Null-Initialisierung übersprungen wird, sofern möglich.
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.
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 einen Schätzwert für die reservierte Anzahl von Bytes ab. 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 Gesamtzeit, die seit Beginn des Prozesses in GC angehalten wurde, ab.
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.
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.
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 den Status einer registrierten Benachrichtigung zurück, ob eine blockierte Garbage Collection abgeschlossen ist. Kann unbefristet 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: