GC.Collect Methode

Bron:

GC.CoreCLR.cs

Bron:

GC.CoreCLR.cs

Bron:

GC.CoreCLR.cs

Bron:

GC.CoreCLR.cs

Bron:

GC.CoreCLR.cs

public:
 static void Collect();

public static void Collect();

static member Collect : unit -> unit

Public Shared Sub Collect ()

Voorbeelden

In het volgende voorbeeld ziet u hoe u de Collect methode gebruikt om een verzameling uit te voeren op alle generaties geheugen. De code genereert een aantal ongebruikte objecten en roept vervolgens de Collect methode aan om ze op te schonen uit het geheugen.

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

Opmerkingen

Gebruik deze methode om te proberen alle geheugen vrij te maken die niet toegankelijk is. Het voert een blokkerende garbagecollection van alle generaties uit.

Alle objecten, ongeacht hoe lang ze in het geheugen zijn, worden in aanmerking genomen voor verzameling; objecten waarnaar wordt verwezen in beheerde code worden echter niet verzameld. Gebruik deze methode om te forceren dat het systeem probeert de maximale hoeveelheid beschikbaar geheugen vrij te maken.

Vanaf het .NET Framework 4.5.1 kunt u de grote object-heap (LOH) comprimeren door de eigenschap GCSettings.LargeObjectHeapCompactionMode in te stellen op GCLargeObjectHeapCompactionMode.CompactOnce voordat u de methode Collect aanroept, zoals in het volgende voorbeeld wordt geïllustreerd.

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

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

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

Zie ook

• Geïnduceerde verzamelingen

Bron:

GC.CoreCLR.cs

Bron:

GC.CoreCLR.cs

Bron:

GC.CoreCLR.cs

Bron:

GC.CoreCLR.cs

Bron:

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)

Parameters

Uitzonderingen

Voorbeelden

In het volgende voorbeeld ziet u hoe u de Collect methode gebruikt om een verzameling uit te voeren op afzonderlijke lagen geheugen. De code genereert een aantal ongebruikte objecten en roept vervolgens de Collect methode aan om ze op te schonen uit het geheugen.

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

Opmerkingen

Gebruik deze methode om te proberen geheugen vrij te maken die niet toegankelijk is. Het gebruik van deze methode garandeert echter niet dat alle ontoegankelijke geheugen in de opgegeven generatie wordt vrijgemaakt.

Als objectveroudering is geïmplementeerd, verzamelt de garbagecollector geen objecten met een generatienummer dat hoger is dan de opgegeven generatie. Als objectveroudering niet wordt geïmplementeerd, houdt de garbagecollection rekening met alle objecten tijdens de garbagecollection.

Gebruik de MaxGeneration eigenschap om de maximaal geldige waarde van de generation parameter te bepalen.

Als u de garbagecollection alle objecten wilt laten overwegen, ongeacht hun generatie, gebruikt u de versie van deze methode waarvoor geen parameters nodig zijn. Gebruik de overbelasting van de GCCollectionMode methode om objecten van de garbagecollector vrij te maken op basis van een GC.Collect(Int32, GCCollectionMode) instelling.

Zie ook

• Geïnduceerde verzamelingen

Bron:

GC.CoreCLR.cs

Bron:

GC.CoreCLR.cs

Bron:

GC.CoreCLR.cs

Bron:

GC.CoreCLR.cs

Bron:

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)

Parameters

Uitzonderingen

Voorbeelden

Het volgende voorbeeld dwingt een garbagecollection af voor objecten van de tweede generatie met de Optimized instelling.

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

Opmerkingen

Gebruik de mode parameter om op te geven of garbagecollection onmiddellijk moet plaatsvinden of alleen als de tijd optimaal is om objecten vrij te maken. Met deze methode wordt niet gegarandeerd dat al het niet-toegankelijke geheugen in de opgegeven generatie wordt vrijgemaakt.

Als u de intrusies van garbagecollection tijdens kritieke perioden in uw toepassing wilt aanpassen, stelt u de LatencyMode eigenschap in.

De garbagecollector verzamelt geen objecten met een generatienummer hoger dan opgegeven door de generation parameter. Gebruik de MaxGeneration eigenschap om de maximaal geldige waarde van generation.

Als u de garbagecollection alle objecten wilt laten overwegen, ongeacht hun generatie, gebruikt u de versie van deze methode waarvoor geen parameters nodig zijn.

Als u de garbagecollection objecten wilt terugvorderen tot een opgegeven generatie objecten, gebruikt u de overbelasting van de GC.Collect(Int32) methode. Wanneer u de maximale generatie opgeeft, worden alle objecten verzameld.

Zie ook

• Geïnduceerde verzamelingen

Bron:

GC.CoreCLR.cs

Bron:

GC.CoreCLR.cs

Bron:

GC.CoreCLR.cs

Bron:

GC.CoreCLR.cs

Bron:

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)

Parameters

Uitzonderingen

Opmerkingen

De volgende tabel bevat een overzicht van de interactie van de mode en blocking parameters:

Als een aanroep naar de Collect(Int32, GCCollectionMode, Boolean) methode een volledige blokkerende garbagecollection uitvoert, kunt u ook de grote object heap comprimeren door de GCSettings.LargeObjectHeapCompactionMode eigenschap in te GCLargeObjectHeapCompactionMode.CompactOnce stellen op voordat u de Collect methode aanroept.

Bron:

GC.CoreCLR.cs

Bron:

GC.CoreCLR.cs

Bron:

GC.CoreCLR.cs

Bron:

GC.CoreCLR.cs

Bron:

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)

Parameters

Opmerkingen

Als blocking dat het is false, bepaalt de GC of een achtergrond of een blokkerende garbagecollection moet worden uitgevoerd. Als compacting dat het is true, voert het een blokkerende garbagecollection uit.

Als compacting dat het is true, compacteert de runtime de kleine object-heap (SOH). De grote object heap (LOH) wordt niet gecomprimeerd tenzij de GCSettings.LargeObjectHeapCompactionMode eigenschap is ingesteld op GCLargeObjectHeapCompactionMode.CompactOnce. Houd er rekening mee dat dit alle blokkerende garbageverzamelingen omvat, niet alleen volledige blokkerende garbageverzamelingen.

U kunt de Collect(Int32, GCCollectionMode, Boolean, Boolean) methode aanroepen om de beheerde heap zo klein mogelijk te beperken, zoals in het volgende codefragment wordt geïllustreerd.

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 Opgeven voor het compacting argument garandeert een compacte, volledige blokkerende garbagecollection. Het instellen van de GCSettings.LargeObjectHeapCompactionMode eigenschap om ervoor te GCLargeObjectHeapCompactionMode.CompactOnce zorgen dat zowel de LOH als de SOH worden gecomprimeerd.