GC.Collect Yöntem
Tanım
Önemli
Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.
Çöp toplamayı zorlar.
Aşırı Yüklemeler
Collect() |
Tüm nesillerin hemen çöp toplamaya zorlar. |
Collect(Int32) |
0. nesilden belirtilen bir nesile kadar hemen çöp toplamaya zorlar. |
Collect(Int32, GCCollectionMode) |
Bir değer tarafından GCCollectionMode belirtilen bir zamanda, 0. nesilden belirtilen bir nesile kadar atık toplamayı zorlar. |
Collect(Int32, GCCollectionMode, Boolean) |
Atık toplamayı nesil 0'dan belirli bir nesile, bir GCCollectionMode değer tarafından belirtilen bir zamanda, toplamanın engellenip engellenmeyeceğini belirten bir değerle zorlar. |
Collect(Int32, GCCollectionMode, Boolean, Boolean) |
Atık toplamayı nesil 0'dan belirli 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
- Kaynak:
- GC.CoreCLR.cs
- 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, kullanılmayan bir dizi nesne oluşturur ve bunları bellekten temizlemek için yöntemini çağırır Collect .
using namespace System;
const int maxGarbage = 1000;
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;
}
}
void main()
{
// Put some objects in memory.
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 ) );
}
// The output from the example resembles the following:
// Memory used before collection: 79,392
// Memory used after full collection: 52,640
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 kazanmayı 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 dikkate alınır; ancak, yönetilen kodda başvuruda bulunan nesneler toplanmaz. Sistemi kullanılabilir en yüksek bellek miktarını geri kazanmayı denemeye 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.
Şunlara uygulanır
Collect(Int32)
- Kaynak:
- GC.CoreCLR.cs
- Kaynak:
- GC.CoreCLR.cs
- Kaynak:
- GC.CoreCLR.cs
0. nesilden belirtilen bir nesile kadar 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
generation
geçerli değil.
Örnekler
Aşağıdaki örnekte, tek tek bellek katmanları üzerinde bir koleksiyon gerçekleştirmek için yönteminin nasıl kullanılacağı Collect gösterilmektedir. Kod, kullanılmayan bir dizi nesne oluşturur ve bunları bellekten temizlemek için yöntemini çağırır Collect .
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
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ı çöp toplama sırasında tüm nesneleri dikkate alır.
parametresinin MaxGeneration en büyük 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. Atık 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.
Şunlara uygulanır
Collect(Int32, GCCollectionMode)
- Kaynak:
- GC.CoreCLR.cs
- Kaynak:
- GC.CoreCLR.cs
- Kaynak:
- GC.CoreCLR.cs
Bir değer tarafından GCCollectionMode belirtilen bir zamanda, 0. nesilden belirtilen bir nesile kadar atık toplamayı 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) olduğunu belirten bir numaralandırma değeri.
Özel durumlar
Ö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 çöp 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 geçerli en yüksek 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.
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.
Şunlara uygulanır
Collect(Int32, GCCollectionMode, Boolean)
- Kaynak:
- GC.CoreCLR.cs
- Kaynak:
- GC.CoreCLR.cs
- Kaynak:
- GC.CoreCLR.cs
Atık toplamayı nesil 0'dan belirli bir nesile, bir GCCollectionMode değer tarafından belirtilen bir zamanda, toplamanın 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) olduğunu belirten bir numaralandırma değeri.
- blocking
- Boolean
true
engelleyici çöp toplama gerçekleştirmek için; false
mümkün olduğunda arka plan çöp toplama işlemi gerçekleştirmek için.
Özel durumlar
Açıklamalar
Aşağıdaki tabloda ve blocking
parametrelerinin mode
etkileşimi özetlemektedir:
mode |
blocking
true
|
blocking
false
|
---|---|---|
Forced veya Default | Engelleme 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 nesil 2 koleksiyonunu tetikler ve sonra döndürür. |
Bir koleksiyon mümkün olan en kısa sürede gerçekleştirilir. Collect(Int32, GCCollectionMode, Boolean) yöntemi bir arka plan koleksiyonu talep eder, ancak bu garanti değildir; koşullara bağlı olarak, bir engelleme koleksiyonu yine de gerçekleştirilebilir. Bir arka plan koleksiyonu zaten devam ediyorsa, yöntemi hemen döndürür. |
Optimized | Çöp toplayıcının durumuna ve parametresine bağlı olarak bir engelleme toplaması generation gerçekleştirilebilir. Atık 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 talep eder, ancak bu garanti değildir; koşullara bağlı olarak, bir engelleme koleksiyonu yine de gerçekleştirilebilir. Atık toplayıcı en iyi performansı sağlamaya çalışır. Bir arka plan koleksiyonu zaten devam ediyorsa, yöntemi hemen döndürür. |
Yöntemine Collect(Int32, GCCollectionMode, Boolean) yapılan bir çağrı tam engelleme çöp toplaması gerçekleştirirse, yöntemini çağırmadan önce özelliğini GCLargeObjectHeapCompactionMode.CompactOnce olarak ayarlayarak büyük nesne yığınını GCSettings.LargeObjectHeapCompactionModeCollect da sıkıştırabilirsiniz.
Şunlara uygulanır
Collect(Int32, GCCollectionMode, Boolean, Boolean)
- Kaynak:
- GC.CoreCLR.cs
- Kaynak:
- GC.CoreCLR.cs
- Kaynak:
- GC.CoreCLR.cs
Atık toplamayı nesil 0'dan belirli 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) olduğunu belirten bir numaralandırma değeri.
- blocking
- Boolean
true
engelleyici çöp toplama gerçekleştirmek için; false
mümkün olduğunda arka plan çöp toplama işlemi 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 blocking
false
GC, arka plan mı yoksa engelleyici çöp toplama mı gerçekleştirmeyeceğine karar verir. ise compacting
true
, engelleyen bir çöp toplama işlemi gerçekleştirir.
ise compacting
true
, çalışma zamanı küçük nesne yığınını (SOH) sıkıştırıyor. Özelliği olarak ayarlanmadığı GCSettings.LargeObjectHeapCompactionModeGCLargeObjectHeapCompactionMode.CompactOncesürece büyük nesne yığını (LOH) sıkıştırılmaz. Bunun yalnızca tam engelleme çöp koleksiyonlarını değil, tüm engelleyici çö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.LargeObjectHeapCompactionMode ayarlanması GCLargeObjectHeapCompactionMode.CompactOnce hem LOH hem de SOH'nin sıkıştırılmasını sağlar.