GC.Collect Metoda

Definicja

Przestrzeń nazw:

System

Zestawy:

netstandard.dll, System.Runtime.dll

Wymusza odzyskiwanie pamięci.

Przeciążenia

Nazwa	Opis
Collect()	Wymusza natychmiastowe odzyskiwanie pamięci wszystkich pokoleń.
Collect(Int32)	Wymusza natychmiastowe odzyskiwanie pamięci z generacji 0 przez określoną generację.
Collect(Int32, GCCollectionMode)	Wymusza odzyskiwanie pamięci z generacji 0 przez określoną generację GCCollectionMode w czasie określonym przez wartość.
Collect(Int32, GCCollectionMode, Boolean)	Wymusza odzyskiwanie pamięci z generacji 0 przez określoną generację GCCollectionMode , w czasie określonym przez wartość, z wartością określającą, czy kolekcja powinna być blokowana.
Collect(Int32, GCCollectionMode, Boolean, Boolean)	Wymusza odzyskiwanie pamięci z generacji 0 przez określoną generację GCCollectionMode , w czasie określonym przez wartość, z wartościami określającymi, czy kolekcja powinna blokować i kompaktować.

Collect()

Źródło:

GC.CoreCLR.cs

Wymusza natychmiastowe odzyskiwanie pamięci wszystkich pokoleń.

public:
 static void Collect();

public static void Collect();

static member Collect : unit -> unit

Public Shared Sub Collect ()

Przykłady

W poniższym przykładzie pokazano, jak używać Collect metody do wykonywania kolekcji na wszystkich generacjach pamięci. Kod generuje wiele nieużywanych obiektów, a następnie wywołuje metodę w celu oczyszczenia Collect ich z pamięci.

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

Uwagi

Użyj tej metody, aby spróbować odzyskać całą pamięć, która jest niedostępna. Wykonuje blokowanie odzyskiwania pamięci wszystkich pokoleń.

Wszystkie obiekty, niezależnie od tego, jak długo znajdują się w pamięci, są brane pod uwagę w przypadku kolekcji; jednak obiekty, do których odwołuje się kod zarządzany, nie są zbierane. Użyj tej metody, aby wymusić na systemie próbę odzyskania maksymalnej ilości dostępnej pamięci.

Począwszy od programu .NET Framework 4.5.1, można skompaktować duży stertę obiektów (LOH), ustawiając GCSettings.LargeObjectHeapCompactionMode właściwość na wartość GCLargeObjectHeapCompactionMode.CompactOnce przed wywołaniem Collect metody, jak pokazano w poniższym przykładzie.

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

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

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

Zobacz też

• Kolekcje indukowane

Collect(Int32)

Źródło:

GC.CoreCLR.cs

Wymusza natychmiastowe odzyskiwanie pamięci z generacji 0 przez określoną generację.

public:
 static void Collect(int generation);

public static void Collect(int generation);

static member Collect : int -> unit

Public Shared Sub Collect (generation As Integer)

Parametry

generation

Int32

Liczba najstarszych pokoleń, które mają być wyrzucane śmieci.

Wyjątki

ArgumentOutOfRangeException

generation jest nieprawidłowy.

Przykłady

W poniższym przykładzie pokazano, jak używać Collect metody do wykonywania kolekcji na poszczególnych warstwach pamięci. Kod generuje wiele nieużywanych obiektów, a następnie wywołuje metodę w celu oczyszczenia Collect ich z pamięci.

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

Uwagi

Użyj tej metody, aby spróbować odzyskać pamięć, która jest niedostępna. Jednak użycie tej metody nie gwarantuje odzyskania całej niedostępnej pamięci w określonej generacji.

W przypadku implementacji starzenia się obiektu moduł odśmieceń pamięci nie zbiera obiektów z numerem generacji, który jest wyższy niż określona generacja. Jeśli starzenie się obiektu nie zostało zaimplementowane, moduł odśmieceń pamięci uwzględnia wszystkie obiekty podczas odzyskiwania pamięci.

Użyj właściwości , MaxGeneration aby określić maksymalną prawidłową wartość parametru generation .

Aby moduł odśmieceń pamięci uwzględniał wszystkie obiekty niezależnie od ich generacji, użyj wersji tej metody, która nie przyjmuje żadnych parametrów. Aby odzyskać obiekty modułu odśmiecanie pamięci na GCCollectionMode podstawie ustawienia, użyj GC.Collect(Int32, GCCollectionMode) przeciążenia metody.

Zobacz też

• Kolekcje indukowane

Collect(Int32, GCCollectionMode)

Źródło:

GC.CoreCLR.cs

Wymusza odzyskiwanie pamięci z generacji 0 przez określoną generację GCCollectionMode w czasie określonym przez wartość.

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)

Parametry

generation

Int32

Liczba najstarszych pokoleń, które mają być wyrzucane śmieci.

mode

GCCollectionMode

Wartość wyliczenia określająca, czy odzyskiwanie pamięci jest wymuszone (Default lub Forced) czy zoptymalizowane (Optimized).

Wyjątki

ArgumentOutOfRangeException

generation jest nieprawidłowy.

— lub —

mode nie jest jedną z GCCollectionMode wartości.

Przykłady

Poniższy przykład wymusza odzyskiwanie pamięci dla obiektów generacji 2 z ustawieniem Optimized .

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

Uwagi

Użyj parametru mode , aby określić, czy odzyskiwanie pamięci powinno nastąpić natychmiast, czy tylko wtedy, gdy czas jest optymalny do odzyskania obiektów. Użycie tej metody nie gwarantuje, że odzyskana jest cała niedostępna pamięć w określonej generacji.

Aby dostosować natrętność odzyskiwania pamięci w krytycznych okresach w aplikacji, ustaw LatencyMode właściwość .

Moduł odśmiecający śmieci nie zbiera obiektów o numerze generacji wyższym niż określony przez generation parametr . Użyj właściwości , MaxGeneration aby określić maksymalną prawidłową wartość generation.

Aby moduł odśmieceń pamięci uwzględniał wszystkie obiekty niezależnie od ich generacji, użyj wersji tej metody, która nie przyjmuje żadnych parametrów.

Aby moduł odśmiecanie pamięci odzyskało obiekty do określonej generacji obiektów, użyj GC.Collect(Int32) przeciążenia metody. Po określeniu maksymalnej generacji wszystkie obiekty są zbierane.

Zobacz też

• Kolekcje indukowane

Collect(Int32, GCCollectionMode, Boolean)

Źródło:

GC.CoreCLR.cs

Wymusza odzyskiwanie pamięci z generacji 0 przez określoną generację GCCollectionMode , w czasie określonym przez wartość, z wartością określającą, czy kolekcja powinna być blokowana.

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)

Parametry

generation

Int32

Liczba najstarszych pokoleń, które mają być wyrzucane śmieci.

mode

GCCollectionMode

Wartość wyliczenia określająca, czy odzyskiwanie pamięci jest wymuszone (Default lub Forced) czy zoptymalizowane (Optimized).

blocking

Boolean

true do wykonania blokującego odzyskiwania pamięci; false w celu wykonania odzyskiwania pamięci w tle, jeśli jest to możliwe.

Wyjątki

ArgumentOutOfRangeException

generation jest nieprawidłowy.

— lub —

mode nie jest jedną z GCCollectionMode wartości.

Uwagi

Poniższa tabela zawiera podsumowanie interakcji parametrów mode i blocking :

mode	blocking jest true	blocking jest false
Forced lub Default	Kolekcja blokująca jest przeprowadzana tak szybko, jak to możliwe. Jeśli kolekcja w tle jest w toku i generation ma wartość 0 lub 1, Collect(Int32, GCCollectionMode, Boolean) metoda natychmiast wyzwala blokującą kolekcję i zwraca wartość po zakończeniu kolekcji. Jeśli kolekcja w tle jest w toku i generation ma wartość 2, metoda czeka na zakończenie kolekcji w tle, wyzwala blokującą kolekcję 2. generacji, a następnie zwraca wartość .	Odbiór jest przeprowadzony tak szybko, jak to możliwe. Metoda Collect(Int32, GCCollectionMode, Boolean) żąda kolekcji w tle, ale nie jest to gwarantowane. W zależności od okoliczności może być nadal wykonywana blokada kolekcji. Jeśli kolekcja w tle jest już w toku, metoda zwraca natychmiast.
Optimized	Może zostać wykonana kolekcja blokująca w zależności od stanu modułu odśmiecenia pamięci i parametru generation . Moduł odśmiecający elementy bezużyteczne próbuje zapewnić optymalną wydajność.	Kolekcję można przeprowadzić w zależności od stanu odśmiecacza pamięci. Metoda Collect(Int32, GCCollectionMode, Boolean) żąda kolekcji w tle, ale nie jest to gwarantowane. W zależności od okoliczności może być nadal wykonywana blokada kolekcji. Moduł odśmiecający elementy bezużyteczne próbuje zapewnić optymalną wydajność. Jeśli kolekcja w tle jest już w toku, metoda zwraca natychmiast.

Jeśli wywołanie Collect(Int32, GCCollectionMode, Boolean) metody wykonuje pełne blokowanie odzyskiwania pamięci, można również skompaktować duży stertę obiektu, ustawiając GCSettings.LargeObjectHeapCompactionMode właściwość na wartość GCLargeObjectHeapCompactionMode.CompactOnce przed wywołaniem Collect metody .

Collect(Int32, GCCollectionMode, Boolean, Boolean)

Źródło:

GC.CoreCLR.cs

Wymusza odzyskiwanie pamięci z generacji 0 przez określoną generację GCCollectionMode , w czasie określonym przez wartość, z wartościami określającymi, czy kolekcja powinna blokować i kompaktować.

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)

Parametry

generation

Int32

Liczba najstarszych pokoleń, które mają być wyrzucane śmieci.

mode

GCCollectionMode

Wartość wyliczenia określająca, czy odzyskiwanie pamięci jest wymuszone (Default lub Forced) czy zoptymalizowane (Optimized).

blocking

Boolean

true do wykonania blokującego odzyskiwania pamięci; false w celu wykonania odzyskiwania pamięci w tle, jeśli jest to możliwe.

compacting

Boolean

true skompaktować mały stertę obiektu; false tylko zamiatać.

Uwagi

Jeśli blocking to false, GC decyduje, czy wykonać tło, czy blokowanie odzyskiwania pamięci. Jeśli compacting wartość to true, wykonuje blokowanie odzyskiwania pamięci.

Jeśli compacting to true, środowisko uruchomieniowe kompaktuje stertę małych obiektów (SOH). Duży stertę obiektu (LOH) nie jest kompaktowany, chyba że właściwość jest ustawiona GCSettings.LargeObjectHeapCompactionMode na GCLargeObjectHeapCompactionMode.CompactOnce. Należy pamiętać, że obejmuje to wszystkie blokowanie odzyskiwania pamięci, a nie tylko pełne blokowanie odzyskiwania pamięci.

Metodę Collect(Int32, GCCollectionMode, Boolean, Boolean) można wywołać, aby zmniejszyć zarządzaną stertę do najmniejszego możliwego rozmiaru, jak pokazano w poniższym fragmentze kodu.

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)

Określenie true argumentu compacting gwarantuje kompaktowanie, pełne blokowanie odzyskiwania pamięci. GCSettings.LargeObjectHeapCompactionMode Ustawienie właściwości w celu GCLargeObjectHeapCompactionMode.CompactOnce zapewnienia, że zarówno LOH, jak i SOH są kompaktowane.