GC Třída

Definice

Obor názvů:

System

Sestavení:

System.Runtime.dll

Zdroj:

GC.cs

Řídí systém uvolňování paměti, službu, která automaticky uvolní nepoužitou paměť.

public ref class GC abstract sealed

public static class GC

type GC = class

Public Class GC

Dědičnost

Object

GC

Příklady

Následující příklad používá několik metod uvolňování paměti k získání informací o generování a paměti o bloku nepoužívaných objektů a jejich tisku do konzoly. Poté se shromáždí nepoužívané objekty a zobrazí se výsledné součty 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

Další informace o tomto rozhraní API najdete v tématu Doplňkové poznámky k rozhraní API pro GC.

Vlastnosti

MaxGeneration

Získá maximální počet generací, které systém aktuálně podporuje.

Metody

AddMemoryPressure(Int64)	Informuje modul runtime o velkém přidělení nespravované paměti, které je třeba vzít v úvahu při plánování uvolňování paměti.
AllocateArray<T>(Int32, Boolean)	Přidělí pole.
AllocateUninitializedArray<T>(Int32, Boolean)	Pokud je to možné, přiděluje pole při přeskočení inicializace nuly.
CancelFullGCNotification()	Zruší registraci oznámení o uvolňování paměti.
Collect()	Vynutí okamžité uvolňování paměti všech generací.
Collect(Int32)	Vynutí okamžité uvolnění paměti z generace 0 do zadané generace.
Collect(Int32, GCCollectionMode)	Vynutí uvolňování paměti z generace 0 do zadané generace v čase určeném GCCollectionMode hodnotou.
Collect(Int32, GCCollectionMode, Boolean)	Vynutí uvolňování paměti z generace 0 do zadané generace 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 do zadané generace v čase určeném GCCollectionMode hodnotou s hodnotami, které určují, zda má být kolekce blokovaná a komprimovaná.
CollectionCount(Int32)	Vrátí počet výskytů uvolňování paměti pro zadanou generaci objektů.
EndNoGCRegion()	Ukončí režim latence oblasti bez uvolňování paměti.
GetAllocatedBytesForCurrentThread()	Získá celkový počet bajtů přidělených aktuálnímu vláknu od začátku jeho životnosti.
GetConfigurationVariables()	Získá konfigurace používané uvolňováním paměti.
GetGCMemoryInfo()	Získá informace o paměti uvolňování paměti.
GetGCMemoryInfo(GCKind)	Získá informace o paměti uvolňování paměti.
GetGeneration(Object)	Vrátí aktuální číslo generace zadaného objektu.
GetGeneration(WeakReference)	Vrátí aktuální číslo generování cíle zadaného slabého odkazu.
GetTotalAllocatedBytes(Boolean)	Získá počet bajtů přidělených za dobu životnosti procesu. Vrácená hodnota nezahrnuje žádné nativní přidělení.
GetTotalMemory(Boolean)	Načte velikost haldy bez fragmentace. Pokud je například celková velikost haldy GC 100 mb a fragmentace, tj. místo zabírající volné objekty, zabírá 40 MB, toto rozhraní API by hlásilo 60 mb. Parametr označuje, zda tato metoda může čekat krátký interval před vrácením, aby systém mohl shromažďovat uvolňování paměti a finalizovat objekty.
GetTotalPauseDuration()	Získá celkovou dobu pozastavení v GC od začátku procesu.
KeepAlive(Object)	Odkazuje na zadaný objekt, což ho činí nezpůsobilým pro uvolňování paměti od začátku aktuální rutiny do bodu, kde je volána tato metoda.
RefreshMemoryLimit()	Dá pokyn systému uvolňování paměti, aby překonfiguroval sám sebe tím, že zjistí různá omezení paměti v systému.
RegisterForFullGCNotification(Int32, Int32)	Určuje, že má být vyvolána oznámení o uvolňování paměti, pokud podmínky upřednostňují úplné uvolňování paměti a po dokončení kolekce.
RegisterNoGCRegionCallback(Int64, Action)	Zaregistruje zpětné volání, které se má vyvolat, když je v oblasti bez uvolňování paměti přiděleno určité množství paměti.
RemoveMemoryPressure(Int64)	Informuje modul runtime, že nespravovaná paměť byla uvolněna a již není nutné ji vzít v úvahu při plánování uvolňování paměti.
ReRegisterForFinalize(Object)	Požaduje, aby systém volal finalizátor pro zadaný objekt, pro který SuppressFinalize(Object) byl dříve volána.
SuppressFinalize(Object)	Vyžaduje, aby modul CLR (Common Language Runtime) nevolal finalizátor pro zadaný objekt.
TryStartNoGCRegion(Int64)	Pokusí se zakázat uvolňování paměti během provádění kritické cesty, pokud je k dispozici zadané množství paměti.
TryStartNoGCRegion(Int64, Boolean)	Pokusí se zakázat uvolňování paměti během provádění kritické cesty, pokud je k dispozici zadané množství paměti, a určuje, zda systém uvolňování paměti provede úplné blokování uvolňování paměti, pokud není zpočátku k dispozici dostatek paměti.
TryStartNoGCRegion(Int64, Int64)	Pokusí se zakázat uvolňování paměti během provádění kritické cesty, pokud je pro haldu velkého objektu a haldu malého objektu k dispozici zadané množství paměti.
TryStartNoGCRegion(Int64, Int64, Boolean)	Pokusí se zakázat uvolňování paměti během provádění kritické cesty, pokud je k dispozici zadané množství paměti pro haldu velkého objektu a haldu malého objektu, a určuje, zda uvolňování paměti provede úplné blokování uvolňování paměti, pokud není zpočátku k dispozici dostatek paměti.
WaitForFullGCApproach()	Vrátí stav registrovaného oznámení pro určení, zda hrozí úplné blokování uvolňování paměti modulem Common Language Runtime.
WaitForFullGCApproach(Int32)	Vrátí v zadaném časovém limitu stav registrovaného oznámení pro určení, zda hrozí úplné blokování uvolňování paměti modulem Common Language Runtime.
WaitForFullGCApproach(TimeSpan)	Vrátí v zadaném časovém limitu stav registrovaného oznámení pro určení, zda hrozí úplné blokování uvolňování paměti modulem Common Language Runtime.
WaitForFullGCComplete()	Vrátí stav registrovaného oznámení pro určení, zda se dokončilo úplné, blokující uvolňování paměti modulem Common Language Runtime.
WaitForFullGCComplete(Int32)	Vrátí v zadaném časovém limitu stav registrovaného oznámení pro určení, jestli se dokončilo úplné a blokující uvolňování paměti podle běžného jazyka modulu runtime.
WaitForFullGCComplete(TimeSpan)	Vrátí stav registrovaného oznámení o tom, jestli se dokončilo blokování uvolňování paměti. Může čekat neomezeně dlouho na úplnou kolekci.
WaitForPendingFinalizers()	Pozastaví aktuální vlákno, dokud vlákno, které zpracovává frontu finalizátorů, nevyprázdní danou frontu.

Viz také

• GCSettings
• Uvolněné
• Základy kolekce paměti