GC.Collect Metod

Källa:

GC.CoreCLR.cs

Källa:

GC.CoreCLR.cs

Källa:

GC.CoreCLR.cs

Källa:

GC.CoreCLR.cs

Källa:

GC.CoreCLR.cs

public:
 static void Collect();

public static void Collect();

static member Collect : unit -> unit

Public Shared Sub Collect ()

Exempel

I följande exempel visas hur du använder Collect metoden för att utföra en samling på alla generationers minne. Koden genererar ett antal oanvända objekt och anropar Collect sedan metoden för att rensa dem från minnet.

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

Kommentarer

Använd den här metoden för att försöka frigöra allt minne som inte är tillgängligt. Den utför en blockerande skräpinsamling av alla generationer.

Alla objekt, oavsett hur länge de har funnits i minnet, beaktas för insamling. Objekt som refereras i hanterad kod samlas dock inte in. Använd den här metoden för att tvinga systemet att försöka frigöra den maximala mängden tillgängligt minne.

Från och med .NET Framework 4.5.1 kan du komprimera den stora objekt heapen (LOH) genom att ange egenskapen GCSettings.LargeObjectHeapCompactionMode till GCLargeObjectHeapCompactionMode.CompactOnce innan du anropar metoden Collect, vilket visas i följande exempel.

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

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

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

Se även

• Inducerade samlingar

Källa:

GC.CoreCLR.cs

Källa:

GC.CoreCLR.cs

Källa:

GC.CoreCLR.cs

Källa:

GC.CoreCLR.cs

Källa:

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)

Parametrar

Undantag

Exempel

I följande exempel visas hur du använder Collect metoden för att utföra en samling på enskilda minneslager. Koden genererar ett antal oanvända objekt och anropar Collect sedan metoden för att rensa dem från minnet.

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

Använd den här metoden för att försöka frigöra minne som inte är tillgängligt. Men att använda den här metoden garanterar inte att allt otillgängligt minne i den angivna generationen frigörs.

Om objektens åldrande implementeras samlar skräpinsamlaren inte in objekt med ett generationsnummer som är högre än den angivna generationen. Om objektets åldrande inte implementeras tar skräpinsamlaren hänsyn till alla objekt under skräpinsamlingen.

Använd egenskapen MaxGeneration för att fastställa det maximala giltiga värdet för parametern generation .

Om du vill att skräpinsamlaren ska ta hänsyn till alla objekt oavsett generering använder du den version av metoden som inte tar några parametrar. Om du vill att skräpinsamlaren ska frigöra objekt baserat på en GCCollectionMode inställning använder du GC.Collect(Int32, GCCollectionMode) metodens överlagring.

Se även

• Inducerade samlingar

Källa:

GC.CoreCLR.cs

Källa:

GC.CoreCLR.cs

Källa:

GC.CoreCLR.cs

Källa:

GC.CoreCLR.cs

Källa:

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)

Parametrar

Undantag

Exempel

I följande exempel framtvingas en skräpinsamling för objekt i generation 2 med inställningen Optimized .

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

Kommentarer

Använd parametern mode för att ange om skräpinsamling ska ske omedelbart eller endast om tiden är optimal för att frigöra objekt. Med den här metoden garanteras inte att allt otillgängligt minne i den angivna genereringen frigörs.

Om du vill justera skräpinsamlingens störande egenskaper under kritiska perioder i programmet anger du LatencyMode egenskapen.

Skräpinsamlaren samlar inte in objekt med ett generationsnummer som är högre än vad som anges av parametern generation . Använd egenskapen MaxGeneration för att fastställa det maximala giltiga värdet för generation.

Om du vill att skräpinsamlaren ska ta hänsyn till alla objekt oavsett generering använder du den version av metoden som inte tar några parametrar.

Om du vill att skräpinsamlaren ska frigöra objekt upp till en angiven generering av objekt använder du GC.Collect(Int32) metodens överlagring. När du anger den maximala genereringen samlas alla objekt in.

Se även

• Inducerade samlingar

Källa:

GC.CoreCLR.cs

Källa:

GC.CoreCLR.cs

Källa:

GC.CoreCLR.cs

Källa:

GC.CoreCLR.cs

Källa:

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)

Parametrar

Undantag

Kommentarer

I följande tabell sammanfattas interaktionen mellan parametrarna mode och blocking :

Om ett anrop till Collect(Int32, GCCollectionMode, Boolean) metoden utför en fullständig blockerande skräpinsamling kan du också komprimera den stora objekthögen GCSettings.LargeObjectHeapCompactionMode genom att ange egenskapen till GCLargeObjectHeapCompactionMode.CompactOnce innan du Collect anropar metoden.

Källa:

GC.CoreCLR.cs

Källa:

GC.CoreCLR.cs

Källa:

GC.CoreCLR.cs

Källa:

GC.CoreCLR.cs

Källa:

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)

Parametrar

Kommentarer

Om blocking är falseavgör GC om en bakgrund eller en blockerande skräpinsamling ska utföras. Om compacting är trueutför den en blockerande skräpinsamling.

Om compacting är truekomprimerar körningen den lilla objekthögen (SOH). Den stora objekthögen (LOH) komprimeras inte om inte GCSettings.LargeObjectHeapCompactionMode egenskapen är inställd på GCLargeObjectHeapCompactionMode.CompactOnce. Observera att detta omfattar alla blockerande skräpsamlingar, inte bara fullständiga blockerande skräpsamlingar.

Du kan anropa Collect(Int32, GCCollectionMode, Boolean, Boolean) metoden för att minska den hanterade heapen till minsta möjliga storlek, vilket visas i följande kodfragment.

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)

Om du true anger för argumentet garanteras compacting en komprimerande, fullständig blockering av skräpinsamling. Om du ställer in egenskapen GCSettings.LargeObjectHeapCompactionMode på ser du till GCLargeObjectHeapCompactionMode.CompactOnce att både LOH och SOH komprimeras.