GC.Collect Metoda

Zdroj:

GC.CoreCLR.cs

Zdroj:

GC.CoreCLR.cs

Zdroj:

GC.CoreCLR.cs

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

Zdroj:

GC.CoreCLR.cs

Zdroj:

GC.CoreCLR.cs

Zdroj:

GC.CoreCLR.cs

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

Výjimky

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

Zdroj:

GC.CoreCLR.cs

Zdroj:

GC.CoreCLR.cs

Zdroj:

GC.CoreCLR.cs

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

Výjimky

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

Zdroj:

GC.CoreCLR.cs

Zdroj:

GC.CoreCLR.cs

Zdroj:

GC.CoreCLR.cs

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

Výjimky

Poznámky

Následující tabulka shrnuje interakci mode parametrů a blocking :

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.

Zdroj:

GC.CoreCLR.cs

Zdroj:

GC.CoreCLR.cs

Zdroj:

GC.CoreCLR.cs

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

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í.