GC.Collect Metoda

Definice

Obor názvů:

System

Sestavení:

netstandard.dll, System.Runtime.dll

Vynutí uvolňování paměti.

Přetížení

Name	Description
Collect()	Vynutí okamžité uvolňování paměti všech generací.
Collect(Int32)	Vynutí okamžité uvolňování paměti z generace 0 prostřednictvím zadané generace.
Collect(Int32, GCCollectionMode)	Vynutí uvolňování paměti z generace 0 do zadané generace v okamžiku určeném GCCollectionMode hodnotou.
Collect(Int32, GCCollectionMode, Boolean)	Vynutí uvolňování paměti z generace 0 do zadané generace v okamžiku určeném GCCollectionMode hodnotou s hodnotou určující, zda má být kolekce blokovaná.
Collect(Int32, GCCollectionMode, Boolean, Boolean)	Vynutí uvolňování paměti z generace 0 do zadané generace v době určené GCCollectionMode hodnotou s hodnotami, které určují, zda má kolekce blokovat a komprimovat.

Collect()

Zdroj:

GC.CoreCLR.cs

Vynutí okamžité uvolňování paměti všech generací.

public:
 static void Collect();

public static void Collect();

static member Collect : unit -> unit

Public Shared Sub Collect ()

Příklady

Následující příklad ukazuje, jak použít metodu Collect k provedení kolekce pro všechny generace paměti. Kód vygeneruje řadu nepoužívaných objektů a potom volá metodu Collect , která je vyčistí z paměti.

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

Poznámky

Tuto metodu použijte k pokusu o uvolnění veškeré paměti, která je nepřístupná. Provádí blokování uvolňování paměti všech generací.

Všechny objekty, bez ohledu na to, jak dlouho byly v paměti, jsou považovány za kolekci; Objekty, na které se odkazuje ve spravovaném kódu, se však neshromažďují. Tuto metodu použijte k vynucení, aby se systém pokusil uvolnit maximální množství dostupné paměti.

Počínaje rozhraním .NET Framework 4.5.1 můžete komprimovat velkou haldu objektu (LOH) nastavením GCSettings.LargeObjectHeapCompactionMode vlastnosti před GCLargeObjectHeapCompactionMode.CompactOnce voláním Collect metody, jak ukazuje následující příklad.

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

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

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

Viz také

• Indukované kolekce

Collect(Int32)

Zdroj:

GC.CoreCLR.cs

Vynutí okamžité uvolňování paměti z generace 0 prostřednictvím zadané generace.

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

Počet nejstarší generace, která se má shromáždit z paměti.

Výjimky

ArgumentOutOfRangeException

generation není platný.

Příklady

Následující příklad ukazuje, jak použít metodu Collect k provedení kolekce na jednotlivých vrstvách paměti. Kód vygeneruje řadu nepoužívaných objektů a potom volá metodu Collect , která je vyčistí z paměti.

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

Poznámky

Tuto metodu použijte k pokusu o uvolnění paměti, která je nepřístupná. Použití této metody však nezaručuje, že se uvolní veškerá nepřístupná paměť v zadané generaci.

Pokud je implementováno stárnutí objektu, systém uvolňování paměti neshromažďuje objekty s číslem generování, které je vyšší než zadaná generace. Pokud není implementováno stárnutí objektu, systém uvolňování paměti bere v úvahu všechny objekty během uvolňování paměti.

MaxGeneration Pomocí vlastnosti určete maximální platnou hodnotu parametrugeneration.

Pokud chcete, aby systém uvolňování paměti zvážil všechny objekty bez ohledu na jejich generování, použijte verzi této metody, která nepřijímá žádné parametry. Chcete-li uvolnit objekty uvolňování paměti na GCCollectionMode základě nastavení, použijte GC.Collect(Int32, GCCollectionMode) přetížení metody.

Viz také

• Indukované kolekce

Collect(Int32, GCCollectionMode)

Zdroj:

GC.CoreCLR.cs

Vynutí uvolňování paměti z generace 0 do zadané generace v okamžiku určeném GCCollectionMode hodnotou.

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

Počet nejstarší generace, která se má shromáždit z paměti.

mode

GCCollectionMode

Hodnota výčtu, která určuje, zda je uvolňování paměti vynuceno (Default nebo Forced) nebo optimalizováno (Optimized).

Výjimky

ArgumentOutOfRangeException

generation není platný.

nebo

mode není jednou z GCCollectionMode hodnot.

Příklady

Následující příklad vynutí uvolňování paměti pro objekty generace 2 s Optimized nastavením.

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

Poznámky

Pomocí parametru mode určete, zda se má uvolňování paměti provést okamžitě, nebo pouze v případě, že je čas optimální pro uvolnění objektů. Použití této metody nezaručuje, že veškerá nepřístupná paměť v zadané generaci je uvolněna.

Chcete-li upravit rušivost uvolňování paměti během kritických období v aplikaci, nastavte LatencyMode vlastnost.

Systém uvolňování paměti neshromažďuje objekty s číslem generování vyšším, než je určené parametrem generation . MaxGeneration Pomocí vlastnosti určete maximální platnou generationhodnotu .

Pokud chcete, aby systém uvolňování paměti zvážil všechny objekty bez ohledu na jejich generování, použijte verzi této metody, která nepřijímá žádné parametry.

Chcete-li, aby uvolňování paměti uvolnit objekty až do zadané generace objektů, použijte GC.Collect(Int32) přetížení metody. Při zadání maximální generace se shromažďují všechny objekty.

Viz také

• Indukované kolekce

Collect(Int32, GCCollectionMode, Boolean)

Zdroj:

GC.CoreCLR.cs

Vynutí uvolňování paměti z generace 0 do zadané generace v okamžiku určeném GCCollectionMode hodnotou s hodnotou určující, zda má být kolekce blokovaná.

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

Počet nejstarší generace, která se má shromáždit z paměti.

mode

GCCollectionMode

Hodnota výčtu, která určuje, zda je uvolňování paměti vynuceno (Default nebo Forced) nebo optimalizováno (Optimized).

blocking

Boolean

true k provedení blokování uvolňování paměti; false pokud je to možné, proveďte uvolňování paměti na pozadí.

Výjimky

ArgumentOutOfRangeException

generation není platný.

nebo

mode není jednou z GCCollectionMode hodnot.

Poznámky

Následující tabulka shrnuje interakci mode s parametry blocking :

mode	blocking je true	blocking je false
Forced nebo Default	Blokující kolekce se provádí co nejdříve. Pokud probíhá kolekce na pozadí a generation je 0 nebo 1, Collect(Int32, GCCollectionMode, Boolean) metoda okamžitě aktivuje blokující kolekci a vrátí se po dokončení kolekce. Pokud probíhá kolekce na pozadí a generation je 2, metoda počká, dokud se kolekce pozadí nedokončí, aktivuje blokující kolekci 2. generace a vrátí se.	Sběr se provede co nejdříve. Metoda Collect(Int32, GCCollectionMode, Boolean) požaduje kolekci na pozadí, což však není zaručeno; v závislosti na okolnostech může být přesto provedena blokující kolekce. Pokud již probíhá sběr na pozadí, metoda se vrátí okamžitě.
Optimized	Blokující kolekce může být provedena v závislosti na stavu garbage collectoru a parametru generation. Systém garbage collector se snaží zajistit optimální výkon.	V závislosti na stavu garbage collectoru může být proveden sběr. Metoda Collect(Int32, GCCollectionMode, Boolean) požaduje kolekci na pozadí, což však není zaručeno; v závislosti na okolnostech může být přesto provedena blokující kolekce. Systém garbage collector se snaží zajistit optimální výkon. Pokud již probíhá sběr na pozadí, metoda se vrátí okamžitě.

Pokud volání Collect(Int32, GCCollectionMode, Boolean) metody provádí úplné blokování uvolňování paměti, můžete také komprimovat velkou haldu objektu nastavením GCSettings.LargeObjectHeapCompactionMode vlastnosti před GCLargeObjectHeapCompactionMode.CompactOnce voláním Collect metody.

Collect(Int32, GCCollectionMode, Boolean, Boolean)

Zdroj:

GC.CoreCLR.cs

Vynutí uvolňování paměti z generace 0 do zadané generace v době určené GCCollectionMode hodnotou s hodnotami, které určují, zda má kolekce blokovat a komprimovat.

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

Počet nejstarší generace, která se má shromáždit z paměti.

mode

GCCollectionMode

Hodnota výčtu, která určuje, zda je uvolňování paměti vynuceno (Default nebo Forced) nebo optimalizováno (Optimized).

blocking

Boolean

true k provedení blokování uvolňování paměti; false pokud je to možné, proveďte uvolňování paměti na pozadí.

compacting

Boolean

true komprimovat malou haldu objektu; false jen uklidit.

Poznámky

Pokud blocking je false, uvolňování paměti rozhodne, zda provést pozadí nebo blokování uvolňování paměti. Pokud compacting ano true, provede blokování uvolňování paměti.

Pokud compacting ano true, modul runtime zkomprimuje malou haldu objektu (SOH). Velká halda objektu (LOH) není komprimována, pokud GCSettings.LargeObjectHeapCompactionMode není vlastnost nastavena na GCLargeObjectHeapCompactionMode.CompactOnce. Všimněte si, že to zahrnuje všechny blokující uvolňování paměti, nejen úplné blokování uvolňování paměti.

Metodu Collect(Int32, GCCollectionMode, Boolean, Boolean) můžete volat, abyste snížili spravovanou haldu na nejmenší možnou velikost, jak ukazuje následující fragment kódu.

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)

true Určení argumentu compacting zaručuje komprimaci, úplné blokování uvolňování paměti. GCSettings.LargeObjectHeapCompactionMode Nastavením vlastnosti zajistíteGCLargeObjectHeapCompactionMode.CompactOnce, že LOH i SOH budou komprimovány.