GC.Collect Yöntem

Tanım

Ad Alanı:

System

Bütünleştirilmiş Kodlar:

netstandard.dll, System.Runtime.dll

Çöp toplamayı zorlar.

Aşırı Yüklemeler

Name	Description
Collect()	Tüm nesillerin hemen çöp toplamaya zorlar.
Collect(Int32)	0. nesilden belirtilen bir nesle hemen çöp toplamaya zorlar.
Collect(Int32, GCCollectionMode)	Bir atık toplamayı 0. nesilden belirtilen bir nesile, bir GCCollectionMode değer tarafından belirtilen bir zamanda zorlar.
Collect(Int32, GCCollectionMode, Boolean)	Bir atık toplamayı 0. nesilden belirtilen bir nesile, bir GCCollectionMode değer tarafından belirtilen bir zamanda, koleksiyonun engellenip engellenmeyeceğini belirten bir değerle zorlar.
Collect(Int32, GCCollectionMode, Boolean, Boolean)	Bir atık toplamayı 0. nesilden belirtilen bir nesile, bir GCCollectionMode değer tarafından belirtilen bir zamanda, koleksiyonun engellenip sıkıştırılmayacağını belirten değerlerle zorlar.

Collect()

Kaynak:

GC.CoreCLR.cs

Tüm nesillerin hemen çöp toplamaya zorlar.

public:
 static void Collect();

public static void Collect();

static member Collect : unit -> unit

Public Shared Sub Collect ()

Örnekler

Aşağıdaki örnekte, tüm bellek nesillerinde bir koleksiyon gerçekleştirmek için yönteminin nasıl kullanılacağı Collect gösterilmektedir. Kod, bir dizi kullanılmayan nesne oluşturur ve bunları bellekten temizlemek için yöntemini çağırır Collect .

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

Açıklamalar

Erişilemeyen tüm belleği geri almayı denemek için bu yöntemi kullanın. Tüm nesillerin engelleyici çöp toplama işlemini gerçekleştirir.

Bellekte ne kadar süre kaldıklarından bağımsız olarak tüm nesneler toplama için kabul edilir; ancak yönetilen kodda başvuruda bulunan nesneler toplanmaz. Sistemi kullanılabilir en yüksek bellek miktarını geri almaya zorlamak için bu yöntemi kullanın.

.NET Framework 4.5.1'den başlayarak, aşağıdaki örnekte gösterildiği gibi yöntemini çağırmadan Collect önce özelliğini GCLargeObjectHeapCompactionMode.CompactOnce olarak ayarlayarak GCSettings.LargeObjectHeapCompactionMode büyük nesne yığınını (LOH) sıkıştırabilirsiniz.

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

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

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

Ayrıca bkz.

• Oluşturulan Koleksiyonlar

Collect(Int32)

Kaynak:

GC.CoreCLR.cs

0. nesilden belirtilen bir nesle hemen çöp toplamaya zorlar.

public:
 static void Collect(int generation);

public static void Collect(int generation);

static member Collect : int -> unit

Public Shared Sub Collect (generation As Integer)

Parametreler

generation

Int32

Atık toplanacak en eski neslin sayısı.

Özel durumlar

ArgumentOutOfRangeException

generation geçerli değil.

Örnekler

Aşağıdaki örnekte, tek tek bellek katmanlarında bir koleksiyon gerçekleştirmek için yönteminin nasıl kullanılacağı Collect gösterilmektedir. Kod, bir dizi kullanılmayan nesne oluşturur ve bunları bellekten temizlemek için yöntemini çağırır Collect .

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

Açıklamalar

Erişilemeyen belleği geri kazanmayı denemek için bu yöntemi kullanın. Ancak bu yöntemin kullanılması, belirtilen nesildeki tüm erişilemez belleğin geri kazanıldığını garanti etmez.

Nesne eskimesi uygulanırsa, atık toplayıcı belirtilen nesilden daha yüksek bir nesil numarasına sahip nesneleri toplamaz. Nesne eskimesi uygulanmazsa, çöp toplayıcı atık toplama sırasında tüm nesneleri dikkate alır.

parametresinin MaxGeneration en yüksek geçerli değerini generation belirlemek için özelliğini kullanın.

Atık toplayıcının oluşturmalarından bağımsız olarak tüm nesneleri dikkate almasını sağlamak için bu yöntemin parametre içermeyen sürümünü kullanın. Çöp toplayıcının bir GCCollectionMode ayara göre nesneleri geri kazanmasını sağlamak için yöntem aşırı yüklemesini GC.Collect(Int32, GCCollectionMode) kullanın.

Ayrıca bkz.

• Oluşturulan Koleksiyonlar

Collect(Int32, GCCollectionMode)

Kaynak:

GC.CoreCLR.cs

Bir atık toplamayı 0. nesilden belirtilen bir nesile, bir GCCollectionMode değer tarafından belirtilen bir zamanda zorlar.

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)

Parametreler

generation

Int32

Atık toplanacak en eski neslin sayısı.

mode

GCCollectionMode

Çöp toplamanın zorlanıp zorlanmadığını (Default veya ) veya Forcediyileştirilmiş (Optimized) olup olmadığını belirten bir numaralandırma değeri.

Özel durumlar

ArgumentOutOfRangeException

generation geçerli değil.

-veya-

mode değerlerden GCCollectionMode biri değildir.

Örnekler

Aşağıdaki örnek, ayarıyla 2. nesil nesneler için çöp toplamayı zorlar 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

Açıklamalar

Atık toplamanın mode hemen mi yoksa yalnızca nesneleri geri kazanmak için en uygun zaman olduğunda mı gerçekleşeceğini belirtmek için parametresini kullanın. Bu yöntemin kullanılması, belirtilen nesildeki tüm erişilemez belleğin geri kazanıldığını garanti etmez.

Uygulamanızdaki kritik dönemlerde atık toplama işleminin müdahaleciliğini ayarlamak için özelliğini ayarlayın LatencyMode .

Atık toplayıcı, parametresi tarafından belirtilenden daha yüksek bir nesil numarasına generation sahip nesneleri toplamaz. MaxGeneration özelliğini kullanarak geçerli en yüksek değerini generationbelirleyin.

Atık toplayıcının oluşturmalarından bağımsız olarak tüm nesneleri dikkate almasını sağlamak için bu yöntemin parametre içermeyen sürümünü kullanın.

Atık toplayıcının nesneleri belirli bir nesne nesline kadar geri kazanmasını sağlamak için yöntem aşırı yüklemesini GC.Collect(Int32) kullanın. En yüksek nesli belirttiğinizde, tüm nesneler toplanır.

Ayrıca bkz.

• Oluşturulan Koleksiyonlar

Collect(Int32, GCCollectionMode, Boolean)

Kaynak:

GC.CoreCLR.cs

Bir atık toplamayı 0. nesilden belirtilen bir nesile, bir GCCollectionMode değer tarafından belirtilen bir zamanda, koleksiyonun engellenip engellenmeyeceğini belirten bir değerle zorlar.

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)

Parametreler

generation

Int32

Atık toplanacak en eski neslin sayısı.

mode

GCCollectionMode

Çöp toplamanın zorlanıp zorlanmadığını (Default veya ) veya Forcediyileştirilmiş (Optimized) olup olmadığını belirten bir numaralandırma değeri.

blocking

Boolean

true engelleyici çöp toplama gerçekleştirmek için; false mümkün olduğunda bir arka plan çöp toplaması gerçekleştirmek için.

Özel durumlar

ArgumentOutOfRangeException

generation geçerli değil.

-veya-

mode değerlerden GCCollectionMode biri değildir.

Açıklamalar

Aşağıdaki tabloda ve blocking parametrelerinin mode etkileşimi özetlemektedir:

mode	blocking eşittir true	blocking eşittir false
Forced veya Default	Bloke etme koleksiyonu mümkün olan en kısa sürede gerçekleştirilir. Bir arka plan koleksiyonu devam ediyor ve generation 0 veya 1 ise, Collect(Int32, GCCollectionMode, Boolean) yöntem hemen bir engelleme koleksiyonu tetikler ve koleksiyon tamamlandığında döndürür. Bir arka plan koleksiyonu devam ediyor ve generation 2 ise, yöntem arka plan koleksiyonu bitene kadar bekler, engelleyen bir 2. nesil koleksiyonu tetikler ve sonra döndürür.	Bir toplama mümkün olan en kısa sürede gerçekleştirilir. Collect(Int32, GCCollectionMode, Boolean) yöntemi bir arka plan koleksiyonu istemektedir, ancak bu garanti edilmemektedir; koşullara bağlı olarak, engelleme koleksiyonu yine de gerçekleştirilebilir. Eğer bir arka plan koleksiyonu zaten devam ediyorsa, yöntem hemen döner.
Optimized	Çöp toplayıcının durumuna ve generation parametresine bağlı olarak bir engelleyici koleksiyon gerçekleştirilebilir. Çöp toplayıcı en iyi performansı sağlamaya çalışır.	Çöp toplayıcının durumuna bağlı olarak bir toplama gerçekleştirilebilir. Collect(Int32, GCCollectionMode, Boolean) yöntemi bir arka plan koleksiyonu istemektedir, ancak bu garanti edilmemektedir; koşullara bağlı olarak, engelleme koleksiyonu yine de gerçekleştirilebilir. Çöp toplayıcı en iyi performansı sağlamaya çalışır. Eğer bir arka plan koleksiyonu zaten devam ediyorsa, yöntem hemen döner.

Yöntemine Collect(Int32, GCCollectionMode, Boolean) yapılan bir çağrı tam engelleyici çöp toplama işlemi gerçekleştiriyorsa, yöntemini çağırmadan önce özelliğini GCLargeObjectHeapCompactionMode.CompactOnce olarak ayarlayarak GCSettings.LargeObjectHeapCompactionMode büyük nesne yığınını Collect da sıkıştırabilirsiniz.

Collect(Int32, GCCollectionMode, Boolean, Boolean)

Kaynak:

GC.CoreCLR.cs

Bir atık toplamayı 0. nesilden belirtilen bir nesile, bir GCCollectionMode değer tarafından belirtilen bir zamanda, koleksiyonun engellenip sıkıştırılmayacağını belirten değerlerle zorlar.

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)

Parametreler

generation

Int32

Atık toplanacak en eski neslin sayısı.

mode

GCCollectionMode

Çöp toplamanın zorlanıp zorlanmadığını (Default veya ) veya Forcediyileştirilmiş (Optimized) olup olmadığını belirten bir numaralandırma değeri.

blocking

Boolean

true engelleyici çöp toplama gerçekleştirmek için; false mümkün olduğunda bir arka plan çöp toplaması gerçekleştirmek için.

compacting

Boolean

true küçük nesne yığınını sıkıştırmak için; false sadece süpürmek için.

Açıklamalar

ise blockingfalseGC, arka plan mı yoksa engelleyici çöp toplama mı gerçekleştireceğine karar verir. ise compactingtrue, engelleyen bir çöp toplama işlemi gerçekleştirir.

ise compactingtrue, çalışma zamanı küçük nesne yığınını (SOH) sıkıştırıyor. Özelliği olarak ayarlanmadığı GCLargeObjectHeapCompactionMode.CompactOncesürece GCSettings.LargeObjectHeapCompactionMode büyük nesne yığını (LOH) sıkıştırılmaz. Bunun yalnızca tam engelleme çöp koleksiyonlarını değil, tüm engelleme çöp toplamalarını içerdiğini unutmayın.

Aşağıdaki kod parçasında Collect(Int32, GCCollectionMode, Boolean, Boolean) gösterildiği gibi yönetilen yığını mümkün olan en küçük boyuta küçültmek için yöntemini çağırabilirsiniz.

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)

bağımsız değişkeninin compacting belirtilmesitrue, sıkıştırma, tam engelleme çöp toplamayı garanti eder. özelliğinin GCSettings.LargeObjectHeapCompactionModeGCLargeObjectHeapCompactionMode.CompactOnce ayarlanması hem LOH hem de SOH'nin sıkıştırılmasını sağlar.