GC-Klasse

  • Artikel

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

Namespace: System
Assembly: mscorlib (in mscorlib.dll)

Syntax

'Declaration
Public NotInheritable Class GC
'Usage
Auf die Member einer statischen Klassen wird direkt ohne Instanz der Klasse zugegriffen.

public static class GC

public ref class GC abstract sealed

public final class GC

public final class GC

Hinweise

Die Methoden dieser Klasse beeinflussen den Zeitpunkt, zu dem die Garbage Collection für ein Objekt durchgeführt wird und zu dem die von einem Objekt reservierten Ressourcen freigegeben werden. Eigenschaften dieser Klasse geben Aufschluss über den im System insgesamt verfügbaren Speicher und die Alterskategorie, d. h. die Generation, des für ein Objekt reservierten Speichers.

Der Garbage Collector verfolgt Objekte, die im verwalteten Speicher abgelegt sind, und gibt sie frei. Der Garbage Collector führt regelmäßig eine Garbage Collection durch, um Speicher freizugeben, der für Objekte reserviert ist, auf die keine gültigen Verweise mehr vorhanden sind. Die Garbage Collection findet automatisch statt, wenn der verfügbare Speicher für eine Speicheranforderung nicht ausreicht. Eine Anwendung kann mit der Collect-Methode auch eine Garbage Collection erzwingen.

Eine Gargabe Collection umfasst folgende Schritte:

  1. Der Garbage Collector sucht nach verwalteten Objekten, auf die in verwaltetem Code verwiesen wird.

  2. Der Garbage Collector versucht, Objekte zu finalisieren, auf die keine Verweise vorhanden sind.

  3. Der Garbage Collector gibt Objekte frei, auf die keine Verweise vorhanden sind, und er stellt deren Speicher wieder zur Verfügung.

Bei einer Garbage Collection gibt der Garbage Collector ein Objekt nicht frei, wenn in verwaltetem Code mindestens ein Verweis auf das Objekt vorhanden ist. Der Garbage Collector erkennt allerdings keine Verweise auf ein Objekt aus nicht verwaltetem Code. Wenn dies nicht ausdrücklich verhindert wird, gibt er deshalb möglicherweise Objekte frei, auf die ausschließlich in nicht verwaltetem Code verwiesen wird. Die KeepAlive-Methode bietet eine Möglichkeit, den Garbage Collector an der Freigabe von Objekten zu hindern, die in nicht verwaltetem Code noch verwendet werden.

Die Implementierungen des Garbage Collectors halten außer den verwalteten Speicherreservierungen keine weiteren Informationen über die von einem Objekt beanspruchten Ressourcen bereit, z. B. über Dateihandles oder Datenbankverbindungen. Wenn ein Typ nicht verwaltete Ressourcen verwendet, die vor der Freigabe einer Instanz des Typs freigegeben werden müssen, kann er einen Finalizer implementieren.

Meist werden Finalizer durch Überschreiben der Object.Finalize-Methode implementiert. In C# oder C++ geschriebene Typen verwenden dagegen Destruktoren, die von Compilern in eine Überschreibung von Object.Finalize umgewandelt werden. Wenn ein Objekt einen Finalizer aufweist, wird dieser vom Garbage Collector in den meisten Fällen vor der Freigabe des Objekts aufgerufen. Der Garbage Collector ist jedoch nicht in allen Situationen zum Aufrufen der Finalizer erforderlich; die SuppressFinalize-Methode zum Beispiel verhindert explizit, dass ein Finalizer aufgerufen wird. Außerdem braucht der Garbage Collector keinen bestimmten Thread zum Finalisieren von Objekten zu verwenden, und es wird keine bestimmte Reihenfolge beim Aufrufen der Finalizer für Objekte garantiert, die aufeinander verweisen und im Übrigen für eine Gargabe Collection zur Verfügung stehen.

In Szenarien, in denen Ressourcen zu bestimmten Zeitpunkten freigegeben werden müssen, können Klassen die IDisposable-Schnittstelle implementieren. Deren IDisposable.Dispose-Methode übernimmt die Ressourcenverwaltung und Bereinigungsaufgaben. Bei Klassen, die Dispose implementieren, muss als Teil des Klassenvertrags angegeben werden, ob und wann Klassenconsumer die Methode zur Bereinigung des Objekts aufrufen müssen. In der Standardeinstellung ruft der Garbage Collector die Dispose-Methode nicht auf. Implementierungen der Dispose-Methode können jedoch Methoden der GC-Klasse aufrufen, um das Finalisierungsverhalten des Garbage Collectors anzupassen.

Es wird empfohlen, dass Gargabe Collectors das Altern von Objekten mithilfe von Generationen unterstützen, obwohl dies nicht zwingend erforderlich ist. Eine Generation ist eine Maßeinheit für das relative Alter von Objekten im Arbeitsspeicher. Die Generationszahl, d. h. das Alter, von Objekten gibt an, welcher Generation ein Objekt angehört. Später erstellte Objekte gehören einer neueren Generation an und weisen niedrigere Generationszahlen auf als Objekte, die im Lebenszyklus der Anwendung früher erstellt wurden. Objekte der letzten Generation gehören der Generation 0 an.

Hinweise für Implementierer Die vorliegende Implementierung des Garbage Collectors unterstützt drei Generationen von Objekten. Mit MaxGeneration wird die maximale vom System unterstützte Generationszahl bestimmt. Das Altern von Objekten ermöglicht es Anwendungen, die Gargabe Collection auf eine bestimmte Gruppe von Generationen auszurichten, anstatt den Garbage Collector alle Generationen auswerten zu lassen.

Beispiel

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

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

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

package GCCollectIntExample; 

import System.* ;

class MyGCCollectClass
{
    private static final long maxGarbage = 1000;

    public static void main(String[] args)
    {
        MyGCCollectClass myGCCol = new MyGCCollectClass();

        // Determine the maximum number of generations the system
        // garbage collector currently supports.
        Console.WriteLine("The highest generation is {0}", 
            System.Convert.ToString(GC.get_MaxGeneration()));
        myGCCol.MakeSomeGarbage();

        // Determine which generation myGCCol object is stored in.
        Console.WriteLine("Generation: {0}", 
            System.Convert.ToString(GC.GetGeneration(myGCCol)));

        // Determine the best available approximation of the number 
        // of bytes currently allocated in managed memory.
        Console.WriteLine("Total Memory: {0}", 
            System.Convert.ToString(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}", 
            System.Convert.ToString(GC.GetGeneration(myGCCol)));
        Console.WriteLine("Total Memory: {0}", 
            System.Convert.ToString(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}", 
            System.Convert.ToString(GC.GetGeneration(myGCCol)));
        Console.WriteLine("Total Memory: {0}", 
            System.Convert.ToString(GC.GetTotalMemory(false)));
        Console.Read();
    } //main

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

Vererbungshierarchie

System.Object
  System.GC

Threadsicherheit

Alle öffentlichen statischen (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Plattformen

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 2.0, 1.0

Siehe auch

Referenz

GC-Member
System-Namespace