GC.Collect Methode

Definition

Namespace:

System

Assemblys:

netstandard.dll, System.Runtime.dll

Erzwingt die Garbage Collection.

Überlädt

Name	Beschreibung
Collect()	Erzwingt eine sofortige Garbage Collection aller Generationen.
Collect(Int32)	Erzwingt eine sofortige Garbage Collection von Generation 0 über eine angegebene Generation.
Collect(Int32, GCCollectionMode)	Erzwingt eine Garbage Collection von Generation 0 bis zu einer angegebenen Generation zu einem durch einen GCCollectionMode Wert angegebenen Zeitpunkt.
Collect(Int32, GCCollectionMode, Boolean)	Erzwingt eine Garbage Collection von Generation 0 bis zu einer angegebenen Generation zu einem durch einen GCCollectionMode Wert angegebenen Zeitpunkt, wobei ein Wert angegeben wird, der angibt, ob die Auflistung blockiert werden soll.
Collect(Int32, GCCollectionMode, Boolean, Boolean)	Erzwingt eine Garbage Collection von Generation 0 bis zu einer angegebenen Generation zu einem zeitpunkt, der durch einen GCCollectionMode Wert angegeben wird, mit Werten, die angeben, ob die Auflistung blockiert und komprimiert werden soll.

Collect()

Quelle:

GC.CoreCLR.cs

Erzwingt eine sofortige Garbage Collection aller Generationen.

public:
 static void Collect();

public static void Collect();

static member Collect : unit -> unit

Public Shared Sub Collect ()

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie die Collect Methode zum Ausführen einer Auflistung auf allen Generationen des Arbeitsspeichers verwendet wird. Der Code generiert eine Reihe nicht verwendeter Objekte und ruft dann die Collect Methode auf, um sie aus dem Arbeitsspeicher zu bereinigen.

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 Speicher freizugeben, auf den nicht zugegriffen werden kann. Es führt eine blockierende Garbage Collection aller Generationen durch.

Alle Objekte, unabhängig davon, wie lange sie im Speicher waren, werden für die Sammlung berücksichtigt; Objekte, auf die in verwaltetem Code verwiesen wird, werden jedoch nicht erfasst. Verwenden Sie diese Methode, um zu erzwingen, dass das System versucht, den maximal verfügbaren Arbeitsspeicher freizugeben.

Ab .NET Framework 4.5.1 können Sie den Heap (Large Object Heap, LOH) komprimieren, indem Sie die GCSettings.LargeObjectHeapCompactionMode Eigenschaft GCLargeObjectHeapCompactionMode.CompactOnce vor dem Aufrufen der Collect Methode festlegen, wie im folgenden Beispiel dargestellt.

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

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

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

Weitere Informationen

• Indizierte Collections

Collect(Int32)

Quelle:

GC.CoreCLR.cs

Erzwingt eine sofortige Garbage Collection von Generation 0 über eine angegebene Generation.

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

generation

Int32

Die Anzahl der ältesten Generation, die gesammelt werden soll.

Ausnahmen

ArgumentOutOfRangeException

generation ist ungültig.

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie die Collect Methode zum Ausführen einer Auflistung auf einzelnen Speicherebenen verwendet wird. Der Code generiert eine Reihe nicht verwendeter Objekte und ruft dann die Collect Methode auf, um sie aus dem Arbeitsspeicher zu bereinigen.

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 Arbeitsspeicher freizugeben, auf den nicht zugegriffen werden kann. Die Verwendung dieser Methode garantiert jedoch nicht, dass der gesamte nicht zugängliche Speicher in der angegebenen Generation zurückgefordert wird.

Wenn die Objektalterung implementiert ist, sammelt der Garbage Collector keine Objekte mit einer Generationsnummer, die höher als die angegebene Generation ist. Wenn das Altern von Objekten 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 der Generierung berücksichtigt, verwenden Sie die Version dieser Methode, die keine Parameter akzeptiert. Verwenden Sie die GC.Collect(Int32, GCCollectionMode) Methodenüberladung, um die Garbage Collector-Objekte basierend auf einer GCCollectionMode Einstellung zurückzufordern.

Weitere Informationen

• Indizierte Collections

Collect(Int32, GCCollectionMode)

Quelle:

GC.CoreCLR.cs

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

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

generation

Int32

Die Anzahl der ältesten Generation, die gesammelt werden soll.

mode

GCCollectionMode

Ein Enumerationswert, der angibt, ob die Garbage Collection erzwungen (Default oder Forced) oder optimiert (Optimized) ist.

Ausnahmen

ArgumentOutOfRangeException

generation ist ungültig.

- oder -

mode ist keiner der GCCollectionMode Werte.

Beispiele

Im folgenden Beispiel wird eine Garbage Collection für Objekte der Generation 2 mit der Optimized Einstellung erzwungen.

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 optimal ist, um Objekte zurückzugeben. Die Verwendung dieser Methode garantiert nicht, dass alle nicht zugänglichen Speicher in der angegebenen Generation zurückgefordert werden.

Um die Aufdringlichkeit der Garbage Collection während kritischer Zeiträume in Ihrer Anwendung anzupassen, legen Sie die LatencyMode Eigenschaft fest.

Der Garbage Collector sammelt keine Objekte mit einer Generationsnummer, die höher ist als durch den generation Parameter angegeben. Verwenden Sie die MaxGeneration Eigenschaft, um den maximal gültigen Wert von generation.

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

Verwenden Sie die GC.Collect(Int32) Methodenüberladung, um die Garbage Collector-Objekte bis zu einer bestimmten Generation von Objekten zurückzugeben. Wenn Sie die maximale Generation angeben, werden alle Objekte erfasst.

Weitere Informationen

• Indizierte Collections

Collect(Int32, GCCollectionMode, Boolean)

Quelle:

GC.CoreCLR.cs

Erzwingt eine Garbage Collection von Generation 0 bis zu einer angegebenen Generation zu einem durch einen GCCollectionMode Wert angegebenen Zeitpunkt, wobei ein Wert angegeben wird, der angibt, ob die Auflistung blockiert werden soll.

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

generation

Int32

Die Anzahl der ältesten Generation, die gesammelt werden soll.

mode

GCCollectionMode

Ein Enumerationswert, der angibt, ob die Garbage Collection erzwungen (Default oder Forced) oder optimiert (Optimized) ist.

blocking

Boolean

true zur Durchführung einer blockierenden Garbage Collection; false um nach Möglichkeit eine Garbage Collection im Hintergrund auszuführen.

Ausnahmen

ArgumentOutOfRangeException

generation ist ungültig.

- oder -

mode ist keiner der GCCollectionMode Werte.

Hinweise

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

mode	blocking ist true	blocking ist false
Forced oder Default	Eine blockierende Auflistung wird so schnell wie möglich ausgeführt. Wenn eine Hintergrundauflistung ausgeführt wird und generation 0 oder 1 ist, löst die Collect(Int32, GCCollectionMode, Boolean) Methode sofort eine blockierungsauflistung aus und gibt zurück, wenn die Auflistung abgeschlossen ist. Wenn eine Hintergrundauflistung ausgeführt wird und generation 2 ist, wartet die Methode, bis die Hintergrundauflistung abgeschlossen ist, löst eine blockierende Sammlung der Generation 2 aus und gibt dann zurück.	Eine Erhebung wird so schnell wie möglich durchgeführt. Die Collect(Int32, GCCollectionMode, Boolean) Methode fordert eine Hintergrundauflistung an, dies ist jedoch nicht gewährleistet. Abhängig von den Umständen kann eine Blockierungsauflistung weiterhin ausgeführt werden. Wenn eine Hintergrundauflistung bereits ausgeführt wird, gibt die Methode sofort zurück.
Optimized	Eine blockierende Auflistung kann ausgeführt werden, je nach Zustand des Garbage Collectors und des generation-Parameters. Der Garbage Collector versucht, eine optimale Leistung zu erzielen.	Eine Auflistung kann ausgeführt werden, je nach Zustand des Garbage Collectors. Die Collect(Int32, GCCollectionMode, Boolean) Methode fordert eine Hintergrundauflistung an, dies ist jedoch nicht gewährleistet. Abhängig von den Umständen kann eine Blockierungsauflistung weiterhin ausgeführt werden. Der Garbage Collector versucht, eine optimale Leistung zu erzielen. Wenn eine Hintergrundauflistung bereits ausgeführt wird, gibt die Methode sofort zurück.

Wenn ein Aufruf der Collect(Int32, GCCollectionMode, Boolean) Methode eine vollständige Blockierung der Garbage Collection durchführt, können Sie den Heap für große Objekte auch komprimieren, indem Sie die GCSettings.LargeObjectHeapCompactionMode Eigenschaft GCLargeObjectHeapCompactionMode.CompactOnce vor dem Aufrufen der Collect Methode festlegen.

Collect(Int32, GCCollectionMode, Boolean, Boolean)

Quelle:

GC.CoreCLR.cs

Erzwingt eine Garbage Collection von Generation 0 bis zu einer angegebenen Generation zu einem zeitpunkt, der durch einen GCCollectionMode Wert angegeben wird, mit Werten, die angeben, ob die Auflistung blockiert und komprimiert werden soll.

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

generation

Int32

Die Anzahl der ältesten Generation, die gesammelt werden soll.

mode

GCCollectionMode

Ein Enumerationswert, der angibt, ob die Garbage Collection erzwungen (Default oder Forced) oder optimiert (Optimized) ist.

blocking

Boolean

true zur Durchführung einer blockierenden Garbage Collection; false um nach Möglichkeit eine Garbage Collection im Hintergrund auszuführen.

compacting

Boolean

true um den heap des kleinen Objekts zu komprimieren; false nur zu aufräumen.

Hinweise

Wenn blocking ja false, entscheidet die GC, ob ein Hintergrund oder eine blockierte Garbage Collection ausgeführt werden soll. Wenn compacting ja true, führt sie eine blockierte Garbage Collection durch.

Wenn compacting ja true, komprimiert die Laufzeit den Heap (Small Object Heap, SOH). Der Heap für große Objekte (LOH) wird nicht komprimiert, es sei denn, die GCSettings.LargeObjectHeapCompactionMode Eigenschaft ist auf festgelegt GCLargeObjectHeapCompactionMode.CompactOnce. Beachten Sie, dass dies alle blockierenden Garbage Collections umfasst, nicht nur vollständige Blockierung von Garbage Collections.

Sie können die Collect(Int32, GCCollectionMode, Boolean, Boolean) Methode aufrufen, um den verwalteten Heap so gering wie möglich 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ändige Blockierung der Garbage Collection. Durch Festlegen der GCSettings.LargeObjectHeapCompactionMode Eigenschaft wird GCLargeObjectHeapCompactionMode.CompactOnce sichergestellt, dass sowohl LOH als auch SOH komprimiert werden.