GC.Collect Metoda

Reference

Definice

Obor názvů:: System

Sestavení:: System.Runtime.dll

Sestavení:: mscorlib.dll

Sestavení:: netstandard.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

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

Přetížení

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 až po zadanou generaci.
Collect(Int32, GCCollectionMode)	Vynutí uvolňování paměti z generace 0 do zadaného generování v čase určeném GCCollectionMode hodnotou.
Collect(Int32, GCCollectionMode, Boolean)	Vynutí uvolňování paměti z generace 0 přes zadané generování v čase 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 přes zadanou generaci v čase určeném GCCollectionMode hodnotou s hodnotami, které určují, zda má být kolekce blokující a komprimovaná.

Collect()

Zdroj:: GC.CoreCLR.cs

Zdroj:: GC.CoreCLR.cs

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 pak zavolá metodu Collect , která je vyčistí z paměti.

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

Poznámky

Tuto metodu použijte k pokusu o uvolnění veškeré paměti, která je nepřístupná. Provádí blokující 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í. Pomocí této metody vynutíte, aby se systém pokusil uvolnit maximální velikost dostupné paměti.

Počínaje rozhraním .NET Framework 4.5.1 můžete zkomprimovat haldu velkého objektu (LOH) nastavením GCSettings.LargeObjectHeapCompactionMode vlastnosti na GCLargeObjectHeapCompactionMode.CompactOnce před 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

Platí pro

Collect(Int32)

Zdroj:: GC.CoreCLR.cs

Zdroj:: GC.CoreCLR.cs

Zdroj:: GC.CoreCLR.cs

Vynutí okamžité uvolňování paměti z generace 0 až po zadanou generaci.

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ších generací, která se má vysbírat 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 pak zavolá metodu Collect , která je vyčistí z paměti.

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

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 veškerá nepřístupná paměť v zadané generaci je uvolněna.

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

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

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

Viz také

Indukované kolekce

Platí pro

Collect(Int32, GCCollectionMode)

Zdroj:: GC.CoreCLR.cs

Zdroj:: GC.CoreCLR.cs

Zdroj:: GC.CoreCLR.cs

Vynutí uvolňování paměti z generace 0 do zadaného generování v čase 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ších generací, která se má vysbírat z paměti.

mode: GCCollectionMode

Hodnota výčtu, která určuje, jestli je uvolňování paměti vynucené (Default nebo Forced) nebo optimalizované (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, jestli má uvolňování paměti proběhnout okamžitě, nebo pouze v případě, že je optimální doba 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í aplikace, nastavte LatencyMode vlastnost .

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

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

Chcete-li, aby systém uvolňování paměti uvolnil objekty až do zadané generace objektů, použijte GC.Collect(Int32) přetížení metody . Když zadáte maximální generování, shromáždí se všechny objekty.

Viz také

Indukované kolekce

Platí pro

Collect(Int32, GCCollectionMode, Boolean)

Zdroj:: GC.CoreCLR.cs

Zdroj:: GC.CoreCLR.cs

Zdroj:: GC.CoreCLR.cs

Vynutí uvolňování paměti z generace 0 přes zadané generování v čase 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ších generací, která se má vysbírat z paměti.

mode: GCCollectionMode

Hodnota výčtu, která určuje, jestli je uvolňování paměti vynucené (Default nebo Forced) nebo optimalizované (Optimized).

blocking: Boolean

true provést 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 parametrů a blocking :

`mode`	`blocking` je `true`	`blocking` je `false`
Forced nebo Default	Blokující kolekce se provede 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á na dokončení kolekce na pozadí, aktivuje blokující kolekci generace 2 a pak vrátí.	Kolekce se provede co nejdříve. Metoda Collect(Int32, GCCollectionMode, Boolean) požaduje kolekci na pozadí, ale není to zaručeno. V závislosti na okolnostech může být blokující kolekce stále provedena. Pokud již probíhá shromažďování na pozadí, vrátí se metoda okamžitě.
Optimized	Blokující shromažďování může být provedeno v závislosti na stavu systému uvolňování paměti a parametru `generation` . Systém uvolňování paměti se snaží zajistit optimální výkon.	V závislosti na stavu systému uvolňování paměti je možné provést kolekci. Metoda Collect(Int32, GCCollectionMode, Boolean) požaduje kolekci na pozadí, ale není to zaručeno. V závislosti na okolnostech může být blokující kolekce stále provedena. Systém uvolňování paměti se snaží zajistit optimální výkon. Pokud již probíhá shromažďování na pozadí, vrátí se metoda okamžitě.

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

Platí pro

Collect(Int32, GCCollectionMode, Boolean, Boolean)

Zdroj:: GC.CoreCLR.cs

Zdroj:: GC.CoreCLR.cs

Zdroj:: GC.CoreCLR.cs

Vynutí uvolňování paměti z generace 0 přes zadanou generaci v čase určeném GCCollectionMode hodnotou s hodnotami, které určují, zda má být kolekce blokující a komprimovaná.

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ších generací, která se má vysbírat z paměti.

mode: GCCollectionMode

Hodnota výčtu, která určuje, jestli je uvolňování paměti vynucené (Default nebo Forced) nebo optimalizované (Optimized).

blocking: Boolean

true provést 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 haldu malého objektu; false pouze pro zametání.

Poznámky

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

Pokud compacting je true, modul runtime komprimuje haldu malého objektu (SOH). Halda velkého GCSettings.LargeObjectHeapCompactionMode objektu (LOH) není zkomprimovaná, pokud není vlastnost nastavená na GCLargeObjectHeapCompactionMode.CompactOncehodnotu . 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.

Voláním Collect(Int32, GCCollectionMode, Boolean, Boolean) metody můžete zmenšit 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)

Zadání true argumentu compacting zaručuje komprimaci a úplné blokování uvolňování paměti. GCSettings.LargeObjectHeapCompactionMode Nastavením vlastnosti na zajistíteGCLargeObjectHeapCompactionMode.CompactOnce, že se LOH i SOH zkomprimují.

Platí pro

GC.Collect Metoda

Definice

Přetížení

Collect()

Příklady

Poznámky

Viz také

Platí pro

Collect(Int32)

Parametry

Výjimky

Příklady

Poznámky

Viz také

Platí pro

Collect(Int32, GCCollectionMode)

Parametry

Výjimky

Příklady

Poznámky

Viz také

Platí pro

Collect(Int32, GCCollectionMode, Boolean)

Parametry

Výjimky

Poznámky

Platí pro

Collect(Int32, GCCollectionMode, Boolean, Boolean)

Parametry

Poznámky

Platí pro

Váš názor

Další materiály