GC Klass

Definition

public ref class GC abstract sealed

public ref class GC sealed

public static class GC

public sealed class GC

type GC = class

Public Class GC

Public NotInheritable Class GC

Arv

Object

GC

Exempel

I följande exempel används flera GC-metoder för att hämta information om generering och minne om ett block med oanvända objekt och skriva ut det till konsolen. De oanvända objekten samlas sedan in och de resulterande minnessummorna visas.

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

Kommentarer

Klassen GC kontrollerar garbage collectorn. Skräpinsamlaren är en vanlig språkkörningskomponent som styr allokering och frisläppning av hanterat minne. Metoderna i den här klassen påverkar när skräpinsamling utförs på ett objekt och när resurser som allokeras av ett objekt släpps. Egenskaper i den här klassen ger information om den totala mängden minne som är tillgängligt i systemet och ålderskategorin, eller genereringen, av minne som allokerats till ett objekt.

Skräpinsamlaren spårar och återtar objekt som allokerats i hanterat minne. Med jämna mellanrum utför skräpinsamlaren skräpinsamling för att frigöra minne som allokerats till objekt där det inte finns några giltiga referenser. Skräpinsamling sker automatiskt när en minnesbegäran inte kan uppfyllas med tillgängligt ledigt minne. Ett program kan också framtvinga skräpinsamling med hjälp av Collect metoden .

Skräpinsamling består av följande steg:

1. Skräpinsamlaren söker efter hanterade objekt som refereras till i hanterad kod.
2. Skräpinsamlaren försöker slutföra objekt som inte refereras till.
3. Skräpinsamlaren frigör objekt som inte refereras till och återtar deras minne.

Ohanterade resurser

Under en samling frigör inte skräpinsamlaren ett objekt om det hittar en eller flera referenser till objektet i hanterad kod. Skräpinsamlaren känner dock inte igen referenser till ett objekt från ohanterad kod och kan frigöra objekt som endast används i ohanterad kod om det inte uttryckligen hindras från att göra det. Metoden KeepAlive tillhandahåller en mekanism som förhindrar att skräpinsamlaren samlar in objekt som fortfarande används i ohanterad kod.

Förutom hanterade minnesallokeringar underhåller implementeringar av skräpinsamlaren inte information om resurser som innehas av ett objekt, till exempel filhandtag eller databasanslutningar. När en typ använder ohanterade resurser som måste frigöras innan instanser av typen återvinns, kan typen implementera en finalizer.

I de flesta fall implementeras finalizers genom att åsidosätta Object.Finalize-metoden; men typer som skrivs i C# eller C++ implementerar destruktorer, som kompilatorer omvandlar till en åsidosättning av Object.Finalize. Om ett objekt i de flesta fall har en slutförare anropar skräpinsamlaren det innan objektet frigörs. Skräpinsamlaren krävs dock inte för att anropa finalatorer i alla situationer. Metoden förhindrar till exempel SuppressFinalize uttryckligen att ett objekts finalizer anropas. Dessutom krävs inte skräpinsamlaren att använda en särskild tråd för att slutföra objekt, eller garantera den ordning i vilken finaliserare anropas för objekt som refererar till varandra men som annars kan samlas in av skräpinsamlaren.

I scenarier där resurser måste släppas vid en viss tidpunkt kan klasser implementera IDisposable gränssnittet, som innehåller den IDisposable.Dispose metod som utför resurshanterings- och rensningsuppgifter. Klasser som implementeras Dispose måste som en del av sitt klasskontrakt ange om och när klasskonsumenter anropar metoden för att rensa objektet. Skräpinsamlaren anropar inte metoden Dispose som standard; dock kan implementeringar av metoden Dispose anropa metoder i klassen GC för att anpassa finaliseringsbeteendet för skräpinsamlaren.

Mer information om objektslutsättning och mönstret för rensning finns i Rensa ohanterade resurser.

Objektåldring och generationer

Skräpinsamlaren i Common Language Runtime (CLR) har stöd för objektåldring med hjälp av generationer. En generation är en måttenhet för objektens relativa ålder i minnet. Ett objekts generationsnummer, eller ålder, anger den generering som ett objekt tillhör. Objekt som skapats på senare tid är en del av nyare generationer och har lägre generationsnummer än objekt som skapats tidigare i programmets livscykel. Objekt i den senaste generationen finns i generation 0. Den här implementeringen av skräpinsamlaren stöder tre generationer av objekt, generation 0, 1 och 2. Du kan hämta värdet för MaxGeneration egenskapen för att fastställa det maximala generationsnumret som stöds av systemet.

Objektåldring gör att program kan rikta skräpinsamling mot en viss uppsättning generationer i stället för att kräva att skräpinsamlaren utvärderar alla generationer. Med överlagringar av metoden Collect som innehåller en generation parameter kan du ange den äldsta generationen som ska samlas in med skräp.

Inaktivera skräphantering

Skräpinsamlaren stöder ett latensläge utan GC-region som kan användas under körning av kritiska sekvenser där skräpinsamling kan påverka ett programs prestanda negativt. Inget svarstidsläge för GC-regionen kräver att du anger en mängd minne som kan allokeras utan interferens från skräpinsamlaren. Om körningen kan allokera det minnet utför körningen inte någon skräpinsamling medan kod i den kritiska sökvägen körs.

Du definierar början av den kritiska sökvägen för regionen utan GC genom att anropa en av funktionens överlagringar för TryStartNoGCRegion. Du anger slutet på den kritiska sökvägen genom att anropa EndNoGCRegion metoden.

Du kan inte kapsla anrop till TryStartNoGCRegion metoden och du bör bara anropa EndNoGCRegion metoden om körningen för närvarande inte är i svarstidsläge för GC-regionen. Med andra ord bör du inte anropa TryStartNoGCRegion flera gånger (efter det första metodanropet kommer efterföljande anrop inte att lyckas) och du bör inte förvänta dig att EndNoGCRegion anropen ska lyckas bara för att TryStartNoGCRegion det första anropet lyckades.

Se även

• GCSettings
• Skräpinsamling
• grunderna i skräpinsamling