Condividi tramite

GC.Collect Metodo

  • Riferimento

Definizione

Spazio dei nomi:
System
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Forza la procedura di Garbage Collection.

Overload

Collect()

Forza un'operazione immediata di Garbage Collection di tutte le generazioni.
Collect(Int32)

Forza un immediato Garbage Collection a partire dalla generazione 0 fino a una determinata generazione.
Collect(Int32, GCCollectionMode)

Forza un'operazione di Garbage Collection dalla generazione 0 a una generazione specificata, in un momento specificato dal valore di GCCollectionMode.
Collect(Int32, GCCollectionMode, Boolean)

Forza un'operazione di Garbage Collection dalla generazione 0 fino a una determinata generazione, in un momento specificato dal valore di GCCollectionMode, con un valore che specifica se la raccolta deve essere bloccante.
Collect(Int32, GCCollectionMode, Boolean, Boolean)

Forza un'operazione di Garbage Collection dalla generazione 0 fino a una determinata generazione, in un momento specificato dal valore di GCCollectionMode, con valori che specificano se la raccolta deve essere bloccante e compattante.

Collect()

Origine:
GC.CoreCLR.cs
Origine:
GC.CoreCLR.cs
Origine:
GC.CoreCLR.cs

Forza un'operazione immediata di Garbage Collection di tutte le generazioni.

public:
 static void Collect();
public static void Collect ();
static member Collect : unit -> unit
Public Shared Sub Collect ()

Esempio

Nell'esempio seguente viene illustrato come usare il Collect metodo per eseguire una raccolta in tutte le generazioni di memoria. Il codice genera un numero di oggetti inutilizzati e quindi chiama il Collect metodo per pulirli dalla memoria.

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

Commenti

Usare questo metodo per provare a recuperare tutta la memoria inaccessibile. Esegue un'operazione di Garbage Collection bloccante per tutte le generazioni.

Tutti gli oggetti, indipendentemente dalla durata in cui sono stati in memoria, vengono considerati per la raccolta; tuttavia, gli oggetti a cui si fa riferimento nel codice gestito non vengono raccolti. Usare questo metodo per forzare il sistema per tentare di recuperare la quantità massima di memoria disponibile.

A partire da .NET Framework 4.5.1, è possibile compattare l'heap (LOH) di grandi dimensioni impostando la proprietà su GCLargeObjectHeapCompactionMode.CompactOnce prima di chiamare il GCSettings.LargeObjectHeapCompactionModeCollect metodo, come illustrato nell'esempio seguente.

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

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

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

Vedi anche

Si applica a

Collect(Int32)

Origine:
GC.CoreCLR.cs
Origine:
GC.CoreCLR.cs
Origine:
GC.CoreCLR.cs

Forza un immediato Garbage Collection a partire dalla generazione 0 fino a una determinata generazione.

public:
 static void Collect(int generation);
public static void Collect (int generation);
static member Collect : int -> unit
Public Shared Sub Collect (generation As Integer)

Parametri

generation
Int32

Numero della generazione meno recente da sottoporre a Garbage Collection.

Eccezioni

ArgumentOutOfRangeException

generation non è valido.

Esempio

Nell'esempio seguente viene illustrato come usare il Collect metodo per eseguire una raccolta su singoli livelli di memoria. Il codice genera un numero di oggetti inutilizzati e quindi chiama il Collect metodo per pulirli dalla memoria.

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

Commenti

Usare questo metodo per provare a recuperare la memoria inaccessibile. Tuttavia, l'uso di questo metodo non garantisce che tutta la memoria inaccessibile nella generazione specificata venga recuperata.

Se l'invecchiamento dell'oggetto viene implementato, Garbage Collector non raccoglie oggetti con un numero di generazione superiore alla generazione specificata. Se l'invecchiamento dell'oggetto non viene implementato, Garbage Collector considera tutti gli oggetti durante la Garbage Collection.

Utilizzare la MaxGeneration proprietà per determinare il valore massimo valido del generation parametro.

Per avere Garbage Collector considerare tutti gli oggetti indipendentemente dalla generazione, usare la versione di questo metodo che non accetta parametri. Per recuperare oggetti di Garbage Collector in base a un'impostazione GCCollectionMode , usare l'overload del GC.Collect(Int32, GCCollectionMode) metodo.

Vedi anche

Si applica a

Collect(Int32, GCCollectionMode)

Origine:
GC.CoreCLR.cs
Origine:
GC.CoreCLR.cs
Origine:
GC.CoreCLR.cs

Forza un'operazione di Garbage Collection dalla generazione 0 a una generazione specificata, in un momento specificato dal valore di GCCollectionMode.

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)

Parametri

generation
Int32

Numero della generazione meno recente da sottoporre a Garbage Collection.

mode
GCCollectionMode

Valore di enumerazione che specifica se l'operazione di Garbage Collection è forzata (Default o Forced) o ottimizzata (Optimized).

Eccezioni

ArgumentOutOfRangeException

generation non è valido.

-oppure-

mode non è uno dei valori di GCCollectionMode .

Esempio

Nell'esempio seguente viene forzata una Garbage Collection per gli oggetti di seconda generazione con l'impostazione 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

Commenti

Usare il mode parametro per specificare se Garbage Collection deve verificarsi immediatamente o solo se il tempo è ottimale per recuperare gli oggetti. L'uso di questo metodo non garantisce che venga recuperata tutta la memoria inaccessibile nella generazione specificata.

Per modificare l'intrusivazza di Garbage Collection durante i periodi critici dell'applicazione, impostare la LatencyMode proprietà .

Garbage Collector non raccoglie oggetti con un numero di generazione superiore a quello specificato dal generation parametro. Utilizzare la MaxGeneration proprietà per determinare il valore massimo valido di generation.

Per avere Garbage Collector considerare tutti gli oggetti indipendentemente dalla generazione, usare la versione di questo metodo che non accetta parametri.

Per recuperare gli oggetti Garbage Collector fino a una generazione specificata di oggetti, usare l'overload del GC.Collect(Int32) metodo. Quando si specifica la generazione massima, vengono raccolti tutti gli oggetti.

Vedi anche

Si applica a

Collect(Int32, GCCollectionMode, Boolean)

Origine:
GC.CoreCLR.cs
Origine:
GC.CoreCLR.cs
Origine:
GC.CoreCLR.cs

Forza un'operazione di Garbage Collection dalla generazione 0 fino a una determinata generazione, in un momento specificato dal valore di GCCollectionMode, con un valore che specifica se la raccolta deve essere bloccante.

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)

Parametri

generation
Int32

Numero della generazione meno recente da sottoporre a Garbage Collection.

mode
GCCollectionMode

Valore di enumerazione che specifica se l'operazione di Garbage Collection è forzata (Default o Forced) o ottimizzata (Optimized).

blocking
Boolean

true per eseguire una procedura di Garbage Collection; false per eseguire una procedura di Garbage Collection in background, se possibile.

Eccezioni

ArgumentOutOfRangeException

generation non è valido.

-oppure-

mode non è uno dei valori di GCCollectionMode .

Commenti

Nella tabella seguente viene riepilogata l'interazione dei parametri mode e blocking.

mode blocking è true blocking è false
Forced o Default Viene eseguita una raccolta di blocco il prima possibile. Se è in corso una raccolta in background e generation è 0 o 1, il metodo Collect(Int32, GCCollectionMode, Boolean) attiva immediatamente una raccolta di blocco e quando la raccolta viene completata esce dalla funzione. Se è in corso una raccolta in background e generation è 2, il metodo attende fino a quando la raccolta in background non viene completata, attiva una raccolta di blocco di generazione 2 ed esce dalla funzione. Viene eseguita una raccolta il prima possibile. Il metodo Collect(Int32, GCCollectionMode, Boolean) richiede una raccolta in background, la cui esecuzione non è comunque garantita. A seconda della situazione, può venire comunque eseguita una raccolta di blocco. Se è già in corso una raccolta in background, il metodo viene restituito immediatamente.
Optimized Può venire eseguita una raccolta di blocco, a seconda dello stato del Garbage Collector e del parametro generation. Il Garbage Collector tenta di garantire prestazioni ottimali. È possibile eseguire una raccolta, a seconda dello stato del Garbage Collector. Il metodo Collect(Int32, GCCollectionMode, Boolean) richiede una raccolta in background, la cui esecuzione non è comunque garantita. A seconda della situazione, può venire comunque eseguita una raccolta di blocco. Il Garbage Collector tenta di garantire prestazioni ottimali. Se è già in corso una raccolta in background, il metodo viene restituito immediatamente.

Se una chiamata al metodo Collect(Int32, GCCollectionMode, Boolean) esegue una procedura completa di Garbage Collection bloccante, è anche possibile compattare gli heap di oggetti grandi impostando la proprietà GCSettings.LargeObjectHeapCompactionMode su GCLargeObjectHeapCompactionMode.CompactOnce prima di chiamare il metodo Collect.

Si applica a

Collect(Int32, GCCollectionMode, Boolean, Boolean)

Origine:
GC.CoreCLR.cs
Origine:
GC.CoreCLR.cs
Origine:
GC.CoreCLR.cs

Forza un'operazione di Garbage Collection dalla generazione 0 fino a una determinata generazione, in un momento specificato dal valore di GCCollectionMode, con valori che specificano se la raccolta deve essere bloccante e compattante.

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)

Parametri

generation
Int32

Numero della generazione meno recente da sottoporre a Garbage Collection.

mode
GCCollectionMode

Valore di enumerazione che specifica se l'operazione di Garbage Collection è forzata (Default o Forced) o ottimizzata (Optimized).

blocking
Boolean

true per eseguire una procedura di Garbage Collection; false per eseguire una procedura di Garbage Collection in background, se possibile.

compacting
Boolean

true per comprimere l'heap degli oggetti piccoli; false per la sola organizzazione.

Commenti

Se blocking è false, il GC decide se eseguire uno sfondo o un blocco di Garbage Collection. Se compacting è true, esegue un blocco di Garbage Collection.

Se compacting è true, il runtime compatta l'heap (SOH). L'heap (LOH) di grandi dimensioni non è compattato a meno che la GCSettings.LargeObjectHeapCompactionMode proprietà non sia impostata su GCLargeObjectHeapCompactionMode.CompactOnce. Si noti che questo include tutti i blocchi di Garbage Collections, non solo il blocco completo delle Garbage Collections.

È possibile chiamare il metodo per ridurre l'heap Collect(Int32, GCCollectionMode, Boolean, Boolean) gestito alla dimensione più piccola possibile, come illustrato nel frammento di codice seguente.

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 La specifica per l'argomento garantisce una compattazione, il blocco completo della compacting Garbage Collection. Impostando la GCSettings.LargeObjectHeapCompactionMode proprietà per GCLargeObjectHeapCompactionMode.CompactOnce assicurarsi che sia LOH che SOH siano compattati.

Si applica a