GC.Collect Methode

Quelle:

GC.CoreCLR.cs

Quelle:

GC.CoreCLR.cs

Quelle:

GC.CoreCLR.cs

public:
 static void Collect();

public static void Collect ();

static member Collect : unit -> unit

Public Shared Sub Collect ()

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie Sie mit der Collect -Methode eine Auflistung für alle Speichergenerationen ausführen. Der Code generiert eine Reihe nicht verwendeter Objekte und ruft dann die Collect -Methode auf, um sie aus dem Arbeitsspeicher zu sauber.

using namespace System;

const int maxGarbage = 1000;

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

void main()
{
   // Put some objects in memory.
   MakeSomeGarbage();
   Console::WriteLine("Memory used before collection:       {0:N0}", 
                      GC::GetTotalMemory( false ) );
   
   // Collect all generations of memory.
   GC::Collect();
   Console::WriteLine("Memory used after full collection:   {0:N0}", 
                      GC::GetTotalMemory( true ) );
}
// The output from the example resembles the following:
//       Memory used before collection:       79,392
//       Memory used after full collection:   52,640

using System;

class MyGCCollectClass
{
   private const int maxGarbage = 1000;

   static void Main()
   {
      // Put some objects in memory.
      MyGCCollectClass.MakeSomeGarbage();
      Console.WriteLine("Memory used before collection:       {0:N0}",
                        GC.GetTotalMemory(false));

      // Collect all generations of memory.
      GC.Collect();
      Console.WriteLine("Memory used after full collection:   {0:N0}",
                        GC.GetTotalMemory(true));
   }

   static void MakeSomeGarbage()
   {
      Version vt;

      // Create objects and release them to fill up memory with unused objects.
      for(int i = 0; i < maxGarbage; i++) {
         vt = new Version();
      }
   }
}
// The output from the example resembles the following:
//       Memory used before collection:       79,392
//       Memory used after full collection:   52,640

open System

let maxGarbage = 1000

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

// Put some objects in memory.
makeSomeGarbage()
printfn $"Memory used before collection:       {GC.GetTotalMemory false:N0}"

// Collect all generations of memory.
GC.Collect()
printfn $"Memory used after full collection:   {GC.GetTotalMemory true:N0}"

// The output from the example resembles the following:
//       Memory used before collection:       79,392
//       Memory used after full collection:   52,640

Class MyGCCollectClass
     Private Const maxGarbage As Integer = 1000

     Shared Sub Main()
         'Put some objects in memory.
         MyGCCollectClass.MakeSomeGarbage()
         Console.WriteLine("Memory used before collection:       {0:N0}", 
                           GC.GetTotalMemory(False))

         'Collect all generations of memory.
         GC.Collect()
         Console.WriteLine("Memory used after full collection:   {0:N0}", 
                           GC.GetTotalMemory(True))
     End Sub

     Shared 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 
     End Sub
 End Class
' The output from the example resembles the following:
'       Memory used before collection:       79,392
'       Memory used after full collection:   52,640

Hinweise

Verwenden Sie diese Methode, um zu versuchen, den gesamten Arbeitsspeicher wiederzugewinnen, auf den nicht zugegriffen werden kann. Es führt eine blockierende Garbage Collection aller Generationen durch.

Alle Objekte, unabhängig davon, wie lange sie sich im Arbeitsspeicher befinden, werden für die Sammlung berücksichtigt. Objekte, auf die im verwalteten Code verwiesen wird, werden jedoch nicht gesammelt. Verwenden Sie diese Methode, um zu erzwingen, dass das System versucht, die maximale Menge an verfügbarem Arbeitsspeicher zurückzufordern.

Ab dem .NET Framework 4.5.1 können Sie den Heap des großen Objekts (LOH) komprimieren, indem Sie die GCSettings.LargeObjectHeapCompactionMode -Eigenschaft GCLargeObjectHeapCompactionMode.CompactOnce auf festlegen, bevor Sie die Collect -Methode aufrufen, wie im folgenden Beispiel veranschaulicht.

GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce;
GC.Collect();

GCSettings.LargeObjectHeapCompactionMode <- GCLargeObjectHeapCompactionMode.CompactOnce
GC.Collect()

GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce
GC.Collect()

Weitere Informationen

• Indizierte Auflistungen

Quelle:

GC.CoreCLR.cs

Quelle:

GC.CoreCLR.cs

Quelle:

GC.CoreCLR.cs

public:
 static void Collect(int generation);

public static void Collect (int generation);

static member Collect : int -> unit

Public Shared Sub Collect (generation As Integer)

Parameter

Ausnahmen

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie Sie mit der Collect -Methode eine Auflistung auf einzelnen Speicherebenen ausführen. Der Code generiert eine Reihe nicht verwendeter Objekte und ruft dann die Collect -Methode auf, um sie aus dem Arbeitsspeicher zu sauber.

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

Verwenden Sie diese Methode, um zu versuchen, Speicher wiederzugewinnen, auf den nicht zugegriffen werden kann. Die Verwendung dieser Methode garantiert jedoch nicht, dass der gesamte nicht zugängliche Arbeitsspeicher in der angegebenen Generation wieder beansprucht wird.

Wenn die Alterung von Objekten implementiert wird, sammelt der Garbage Collector keine Objekte mit einer Generationsnummer, die höher als die angegebene Generation ist. Wenn die Alterung des Objekts nicht implementiert ist, berücksichtigt der Garbage Collector alle Objekte während der Garbage Collection.

Verwenden Sie die MaxGeneration -Eigenschaft, um den maximal gültigen Wert des generation Parameters zu bestimmen.

Damit der Garbage Collector alle Objekte unabhängig von ihrer Generierung berücksichtigt, verwenden Sie die Version dieser Methode, die keine Parameter akzeptiert. Verwenden Sie GC.Collect(Int32, GCCollectionMode) die Methodenüberladung, damit der Garbage Collector Objekte basierend auf einer GCCollectionMode Einstellung zurückfordert.

Weitere Informationen

• Indizierte Auflistungen

Quelle:

GC.CoreCLR.cs

Quelle:

GC.CoreCLR.cs

Quelle:

GC.CoreCLR.cs

public:
 static void Collect(int generation, GCCollectionMode mode);

public static void Collect (int generation, GCCollectionMode mode);

static member Collect : int * GCCollectionMode -> unit

Public Shared Sub Collect (generation As Integer, mode As GCCollectionMode)

Parameter

Ausnahmen

Beispiele

Das folgende Beispiel erzwingt eine Garbage Collection für Objekte der 2. Generation mit der Optimized Einstellung.

using System;

class Program
{
    static void Main(string[] args)
    {
        GC.Collect(2, GCCollectionMode.Optimized);
    }
}

open System

GC.Collect(2, GCCollectionMode.Optimized)

Class Program

    Public Shared Sub Main()
        GC.Collect(2, GCCollectionMode.Optimized)
    End Sub
End Class

Hinweise

Verwenden Sie den mode -Parameter, um anzugeben, ob die Garbage Collection sofort oder nur dann erfolgen soll, wenn die Zeit für die Rückgewinnung von Objekten optimal ist. Die Verwendung dieser Methode garantiert nicht, dass der gesamte nicht zugängliche Arbeitsspeicher in der angegebenen Generation wieder beansprucht wird.

Legen LatencyMode Sie die -Eigenschaft fest, um die Aufdringlichkeit der Garbage Collection in kritischen Zeiträumen in Ihrer Anwendung anzupassen.

Der Garbage Collector sammelt keine Objekte, deren Generierungsnummer höher als im generation Parameter angegeben ist. Verwenden Sie die MaxGeneration -Eigenschaft, um den maximal gültigen Wert von generationzu bestimmen.

Damit der Garbage Collector alle Objekte unabhängig von ihrer Generierung berücksichtigt, verwenden Sie die Version dieser Methode, die keine Parameter akzeptiert.

Verwenden Sie GC.Collect(Int32) die Methodenüberladung, damit der Garbage Collector Objekte bis zu einer angegebenen Generation von Objekten zurückfordert. Wenn Sie die maximale Generierung angeben, werden alle Objekte gesammelt.

Weitere Informationen

• Indizierte Auflistungen

Quelle:

GC.CoreCLR.cs

Quelle:

GC.CoreCLR.cs

Quelle:

GC.CoreCLR.cs

public:
 static void Collect(int generation, GCCollectionMode mode, bool blocking);

public static void Collect (int generation, GCCollectionMode mode, bool blocking);

static member Collect : int * GCCollectionMode * bool -> unit

Public Shared Sub Collect (generation As Integer, mode As GCCollectionMode, blocking As Boolean)

Parameter

Ausnahmen

Hinweise

Die folgende Tabelle fasst die Interaktion der mode Parameter und blocking zusammen:

Wenn ein Aufruf der Collect(Int32, GCCollectionMode, Boolean) -Methode eine vollständige blockierende Garbage Collection ausführt, können Sie auch den Heap des großen Objekts komprimieren, indem Sie die GCSettings.LargeObjectHeapCompactionMode -Eigenschaft auf GCLargeObjectHeapCompactionMode.CompactOnce festlegen, bevor Sie die Collect Methode aufrufen.

Quelle:

GC.CoreCLR.cs

Quelle:

GC.CoreCLR.cs

Quelle:

GC.CoreCLR.cs

public:
 static void Collect(int generation, GCCollectionMode mode, bool blocking, bool compacting);

public static void Collect (int generation, GCCollectionMode mode, bool blocking, bool compacting);

static member Collect : int * GCCollectionMode * bool * bool -> unit

Public Shared Sub Collect (generation As Integer, mode As GCCollectionMode, blocking As Boolean, compacting As Boolean)

Parameter

Hinweise

Wenn blocking dies der Wert ist false, entscheidet der GC, ob eine Hintergrund- oder eine blockierende Garbage Collection ausgeführt werden soll. Wenn compacting dies der Wert ist true, führt sie eine blockierende Garbage Collection aus.

Wenn compacting ist true, komprimiert die Runtime den Soap (Small Object Heap, SOH). Der Heap des großen Objekts (LOH) wird nur komprimiert, wenn die GCSettings.LargeObjectHeapCompactionMode -Eigenschaft auf GCLargeObjectHeapCompactionMode.CompactOncefestgelegt ist. Beachten Sie, dass dies alle blockierenden Garbage Collections umfasst, nicht nur vollständige blockierende Garbage Collection.

Sie können die Collect(Int32, GCCollectionMode, Boolean, Boolean) -Methode aufrufen, um den verwalteten Heap auf die kleinstmögliche Größe zu reduzieren, wie das folgende Codefragment veranschaulicht.

GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce;
GC.Collect(2, GCCollectionMode.Forced, true, true);

GCSettings.LargeObjectHeapCompactionMode <- GCLargeObjectHeapCompactionMode.CompactOnce
GC.Collect(2, GCCollectionMode.Forced, true, true)

GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce
GC.Collect(2, GCCollectionMode.Forced, True, True)

Die Angabe true für das compacting Argument garantiert eine komprimierende, vollständig blockierende Garbage Collection. Durch Festlegen der GCSettings.LargeObjectHeapCompactionMode Eigenschaft auf GCLargeObjectHeapCompactionMode.CompactOnce wird sichergestellt, dass sowohl der LOH als auch der SOH komprimiert werden.