GC.Collect Metódus

Definíció

Névtér:

System

Szerelvények:

netstandard.dll, System.Runtime.dll

Kényszeríti a szemétgyűjtést.

Túlterhelések

Name	Description
Collect()	Minden generáció azonnali szemétgyűjtését kényszeríti ki.
Collect(Int32)	Azonnali szemétgyűjtés kényszerítése a 0. generációtól egy adott generációig.
Collect(Int32, GCCollectionMode)	A szemétgyűjtés kényszerítése a 0. generációtól egy megadott generáción keresztül, egy GCCollectionMode érték által meghatározott időpontban.
Collect(Int32, GCCollectionMode, Boolean)	A szemétgyűjtés kényszerítése a 0. generációtól egy adott generáción keresztül, egy GCCollectionMode érték által meghatározott időpontban, egy értékkel, amely meghatározza, hogy a gyűjtemény blokkolva legyen-e.
Collect(Int32, GCCollectionMode, Boolean, Boolean)	A szemétgyűjtés kényszerítése a 0. generációtól egy megadott generáción keresztül, egy GCCollectionMode érték által meghatározott időpontban, olyan értékekkel, amelyek meghatározzák, hogy a gyűjteménynek blokkolnia és tömörítenie kell-e a gyűjteményt.

Collect()

Forrás:

GC.CoreCLR.cs

Minden generáció azonnali szemétgyűjtését kényszeríti ki.

public:
 static void Collect();

public static void Collect();

static member Collect : unit -> unit

Public Shared Sub Collect ()

Példák

Az alábbi példa bemutatja, hogyan használható a Collect metódus egy gyűjtemény végrehajtására a memória minden generációján. A kód számos nem használt objektumot hoz létre, majd meghívja a metódust, hogy törölje őket a Collect memóriából.

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

Megjegyzések

Ezzel a módszerrel próbálja meg visszanyerni az összes elérhetetlen memóriát. Minden generáció szemétgyűjtését végzi.

Az összes objektumot, függetlenül attól, hogy mennyi ideig voltak a memóriában, gyűjteménynek tekintjük; azonban a felügyelt kódban hivatkozott objektumok nem lesznek összegyűjtve. Ezzel a módszerrel kényszerítse a rendszert, hogy próbálja meg visszanyerni a rendelkezésre álló memória maximális mennyiségét.

A .NET Framework 4.5.1-től kezdve tömörítheti a nagyméretű objektum halomát (LOH), ha a GCSettings.LargeObjectHeapCompactionMode tulajdonságot GCLargeObjectHeapCompactionMode.CompactOnce értékre állítja, mielőtt meghívja a Collect metódust, ahogyan az az alábbi példában látható.

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

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

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

Lásd még

• Ösztönzött gyűjtemények

Collect(Int32)

Forrás:

GC.CoreCLR.cs

Azonnali szemétgyűjtés kényszerítése a 0. generációtól egy adott generációig.

public:
 static void Collect(int generation);

public static void Collect(int generation);

static member Collect : int -> unit

Public Shared Sub Collect (generation As Integer)

Paraméterek

generation

Int32

A szemétgyűjtés legrégebbi generációjának száma.

Kivételek

ArgumentOutOfRangeException

generation érvénytelen.

Példák

Az alábbi példa bemutatja, hogyan használható a Collect metódus egy gyűjtemény végrehajtására az egyes memóriarétegeken. A kód számos nem használt objektumot hoz létre, majd meghívja a metódust, hogy törölje őket a Collect memóriából.

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

Megjegyzések

Ezzel a módszerrel megpróbálhatja visszanyerni a elérhetetlen memóriát. Ennek a módszernek a használata azonban nem garantálja, hogy a megadott generáció összes elérhetetlen memóriája vissza lesz adva.

Ha az objektumöregedés implementálva van, a szemétgyűjtő nem gyűjti össze a megadott generációnál magasabb generációs számmal rendelkező objektumokat. Ha az objektumöregedés nincs megvalósítva, a szemétgyűjtő figyelembe veszi az összes objektumot a szemétgyűjtés során.

Használja a MaxGeneration tulajdonságot a paraméter maximális érvényes értékének meghatározásához generation .

Ha azt szeretné, hogy a szemétgyűjtő az összes objektumot figyelembe vegye a létrehozásuktól függetlenül, használja a metódus azon verzióját, amely nem vesz figyelembe paramétereket. Ha azt szeretné, hogy a szemétgyűjtő egy GCCollectionMode beállítás alapján visszanyerje az objektumokat, használja a metódus túlterhelését GC.Collect(Int32, GCCollectionMode) .

Lásd még

• Ösztönzött gyűjtemények

Collect(Int32, GCCollectionMode)

Forrás:

GC.CoreCLR.cs

A szemétgyűjtés kényszerítése a 0. generációtól egy megadott generáción keresztül, egy GCCollectionMode érték által meghatározott időpontban.

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)

Paraméterek

generation

Int32

A szemétgyűjtés legrégebbi generációjának száma.

mode

GCCollectionMode

Enumerálási érték, amely meghatározza, hogy a szemétgyűjtés kényszerített (Default vagy ) vagy Forcedoptimalizált (Optimized).

Kivételek

ArgumentOutOfRangeException

generation érvénytelen.

-vagy-

mode nem tartozik az GCCollectionMode értékek közé.

Példák

Az alábbi példa a 2. generációs objektumok szemétgyűjtését kényszeríti ki a Optimized beállítással.

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

Megjegyzések

mode A paraméter használatával megadhatja, hogy a szemétgyűjtésnek azonnal vagy csak akkor kell történnie, ha az idő optimális az objektumok visszanyeréséhez. Ennek a módszernek a használata nem garantálja, hogy a megadott generáció összes elérhetetlen memóriája vissza lesz adva.

Ha módosítani szeretné a szemétgyűjtés tolakodóságát az alkalmazásban kritikus időszakokban, állítsa be a tulajdonságot LatencyMode .

A szemétgyűjtő nem gyűjti a paraméter által generation megadottnál magasabb generációs számmal rendelkező objektumokat. MaxGeneration A tulajdonság használatával határozza meg a maximális érvényes értéketgeneration.

Ha azt szeretné, hogy a szemétgyűjtő az összes objektumot figyelembe vegye a létrehozásuktól függetlenül, használja a metódus azon verzióját, amely nem vesz figyelembe paramétereket.

Ha azt szeretné, hogy a szemétgyűjtő egy adott objektumgenerációig visszakövetelje az objektumokat, használja a metódus túlterhelését GC.Collect(Int32) . A maximális létrehozás megadásakor a rendszer minden objektumot összegyűjt.

Lásd még

• Ösztönzött gyűjtemények

Collect(Int32, GCCollectionMode, Boolean)

Forrás:

GC.CoreCLR.cs

A szemétgyűjtés kényszerítése a 0. generációtól egy adott generáción keresztül, egy GCCollectionMode érték által meghatározott időpontban, egy értékkel, amely meghatározza, hogy a gyűjtemény blokkolva legyen-e.

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)

Paraméterek

generation

Int32

A szemétgyűjtés legrégebbi generációjának száma.

mode

GCCollectionMode

Enumerálási érték, amely meghatározza, hogy a szemétgyűjtés kényszerített (Default vagy ) vagy Forcedoptimalizált (Optimized).

blocking

Boolean

true blokkoló szemétgyűjtés végrehajtása; false háttérbeli szemétgyűjtés végrehajtása, ahol lehetséges.

Kivételek

ArgumentOutOfRangeException

generation érvénytelen.

-vagy-

mode nem tartozik az GCCollectionMode értékek közé.

Megjegyzések

Az alábbi táblázat összefoglalja a paraméterek és mode a paraméterek interakciójátblocking:

mode	blocking van true	blocking van false
Forced vagy Default	A blokkolási gyűjteményt a lehető leghamarabb végrehajtjuk. Ha egy háttérgyűjtemény folyamatban van, és generation 0 vagy 1, a Collect(Int32, GCCollectionMode, Boolean) metódus azonnal aktivál egy blokkolási gyűjteményt, és a gyűjtemény befejezésekor ad vissza. Ha egy háttérgyűjtemény folyamatban van, és generation 2, a metódus megvárja, amíg a háttérgyűjtemény befejeződik, aktivál egy blokkoló 2. generációs gyűjteményt, majd visszatér.	A gyűjteményt a lehető leghamarabb elvégezzük. A Collect(Int32, GCCollectionMode, Boolean) metódus háttérben történő gyűjtést kér, de ez nem garantált; a körülményektől függően ettől függetlenül blokkoló gyűjtésre is sor kerülhet. Ha egy háttérgyűjtemény már folyamatban van, a metódus azonnal visszatér.
Optimized	A szemétgyűjtő állapotától és generation a paramétertől függően blokkoló gyűjtést is lehet végezni. A szemétgyűjtő megpróbálja optimális teljesítményt nyújtani.	A szemétgyűjtő állapotától függően gyűjtést is lehet végezni. A Collect(Int32, GCCollectionMode, Boolean) metódus háttérben történő gyűjtést kér, de ez nem garantált; a körülményektől függően ettől függetlenül blokkoló gyűjtésre is sor kerülhet. A szemétgyűjtő megpróbálja optimális teljesítményt nyújtani. Ha egy háttérgyűjtemény már folyamatban van, a metódus azonnal visszatér.

Ha a Collect(Int32, GCCollectionMode, Boolean) metódus hívása teljes blokkoló szemétgyűjtést hajt végre, tömörítheti a nagy objektum halomját is, ha a tulajdonságot GCSettings.LargeObjectHeapCompactionMode a GCLargeObjectHeapCompactionMode.CompactOnce metódus meghívása előtt állítja Collect be.

Collect(Int32, GCCollectionMode, Boolean, Boolean)

Forrás:

GC.CoreCLR.cs

A szemétgyűjtés kényszerítése a 0. generációtól egy megadott generáción keresztül, egy GCCollectionMode érték által meghatározott időpontban, olyan értékekkel, amelyek meghatározzák, hogy a gyűjteménynek blokkolnia és tömörítenie kell-e a gyűjteményt.

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)

Paraméterek

generation

Int32

A szemétgyűjtés legrégebbi generációjának száma.

mode

GCCollectionMode

Enumerálási érték, amely meghatározza, hogy a szemétgyűjtés kényszerített (Default vagy ) vagy Forcedoptimalizált (Optimized).

blocking

Boolean

true blokkoló szemétgyűjtés végrehajtása; false háttérbeli szemétgyűjtés végrehajtása, ahol lehetséges.

compacting

Boolean

true a kis objektumcsomó tömörítése; false csak a takarításhoz.

Megjegyzések

Ha blocking igen false, a csoportházirend-objektum dönti el, hogy végrehajt-e egy hátteret vagy blokkolja a szemétgyűjtést. Ha compacting igen true, blokkolja a szemétgyűjtést.

Ha compacting igen true, a futtatókörnyezet tömöríti a kis objektum halomját (SOH). A nagy objektum halom (LOH) csak akkor tömöríthető, ha a GCSettings.LargeObjectHeapCompactionMode tulajdonság értéke GCLargeObjectHeapCompactionMode.CompactOnce. Vegye figyelembe, hogy ez magában foglalja az összes szemétgyűjtés blokkolását, nem csak a szemétgyűjtések teljes blokkolását.

Meghívhatja a metódust a Collect(Int32, GCCollectionMode, Boolean, Boolean) felügyelt halom lehető legkisebb méretre való csökkentésére, ahogyan azt az alábbi kódrészlet szemlélteti.

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 Az argumentum megadása garantálja a compacting tömörítést, a szemétgyűjtés teljes blokkolását. Ha úgy állítja be a GCSettings.LargeObjectHeapCompactionMode tulajdonságot GCLargeObjectHeapCompactionMode.CompactOnce , hogy a LOH és az SOH is tömörítve legyen.