Compartir a través de

GC.Collect Método

  • Referencia

Definición

Espacio de nombres:
System
Ensamblado:
System.Runtime.dll
Ensamblado:
mscorlib.dll
Ensamblado:
netstandard.dll

Fuerza a que se lleve a cabo la recolección de elementos no utilizados.

Sobrecargas

Collect()

Fuerza a que se lleve a cabo una recolección de elementos no utilizados de todas las generaciones.
Collect(Int32)

Fuerza a que se lleve a cabo inmediatamente la recolección de elementos no utilizados desde la generación 0 hasta la generación especificada.
Collect(Int32, GCCollectionMode)

Fuerza una recolección de elementos no utilizados desde la generación 0 hasta la generación especificada, en el momento especificado por el valor GCCollectionMode.
Collect(Int32, GCCollectionMode, Boolean)

Fuerza una recolección de elementos no utilizados de generación 0 en una generación especificada, en un momento especificado por un valor de GCCollectionMode, con un valor que especifica si la recolección debe ser de bloqueo.
Collect(Int32, GCCollectionMode, Boolean, Boolean)

Fuerza una recolección de elementos no utilizados de generación 0 en una generación especificada, en un momento especificado por un valor de GCCollectionMode, con valores que especifican si la recolección debe ser de bloqueo y compactante.

Collect()

Source:
GC.CoreCLR.cs
Source:
GC.CoreCLR.cs
Source:
GC.CoreCLR.cs

Fuerza a que se lleve a cabo una recolección de elementos no utilizados de todas las generaciones.

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

Ejemplos

En el ejemplo siguiente se muestra cómo usar el Collect método para realizar una colección en todas las generaciones de memoria. El código genera una serie de objetos no utilizado y, a continuación, llama al Collect método para limpiarlos de la 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

Comentarios

Use este método para intentar reclamar toda la memoria inaccesible. Realiza una recolección de elementos no utilizados de bloqueo de todas las generaciones.

Todos los objetos, independientemente de cuánto tiempo hayan estado en memoria, se consideran para la colección; sin embargo, los objetos a los que se hace referencia en el código administrado no se recopilan. Use este método para forzar al sistema a intentar reclamar la cantidad máxima de memoria disponible.

A partir de .NET Framework 4.5.1, puede compactar el montón de objetos grandes (LOH) estableciendo la GCSettings.LargeObjectHeapCompactionMode propiedad GCLargeObjectHeapCompactionMode.CompactOnce en antes de llamar al Collect método , como se muestra en el ejemplo siguiente.

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

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

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

Consulte también

Se aplica a

Collect(Int32)

Source:
GC.CoreCLR.cs
Source:
GC.CoreCLR.cs
Source:
GC.CoreCLR.cs

Fuerza a que se lleve a cabo inmediatamente la recolección de elementos no utilizados desde la generación 0 hasta la generación especificada.

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

Parámetros

generation
Int32

El número de la generación más antigua de elementos no usados para recolectar.

Excepciones

ArgumentOutOfRangeException

generation no es válido.

Ejemplos

En el ejemplo siguiente se muestra cómo usar el Collect método para realizar una colección en capas individuales de memoria. El código genera una serie de objetos no utilizado y, a continuación, llama al Collect método para limpiarlos de la 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

Comentarios

Use este método para intentar recuperar la memoria inaccesible. Sin embargo, el uso de este método no garantiza que se recupere toda la memoria inaccesible de la generación especificada.

Si se implementa el envejecimiento de objetos, el recolector de elementos no utilizados no recopila objetos con un número de generación mayor que la generación especificada. Si no se implementa el envejecimiento de objetos, el recolector de elementos no utilizados considera todos los objetos durante la recolección de elementos no utilizados.

Use la MaxGeneration propiedad para determinar el valor máximo válido del generation parámetro.

Para que el recolector de elementos no utilizados tenga en cuenta todos los objetos independientemente de su generación, use la versión de este método que no toma ningún parámetro. Para que el recolector de elementos no utilizados recupere objetos en función de una GCCollectionMode configuración, use la sobrecarga del GC.Collect(Int32, GCCollectionMode) método .

Consulte también

Se aplica a

Collect(Int32, GCCollectionMode)

Source:
GC.CoreCLR.cs
Source:
GC.CoreCLR.cs
Source:
GC.CoreCLR.cs

Fuerza una recolección de elementos no utilizados desde la generación 0 hasta la generación especificada, en el momento especificado por el valor 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)

Parámetros

generation
Int32

El número de la generación más antigua de elementos no usados para recolectar.

mode
GCCollectionMode

Un valor de enumeración que especifica si se fuerza la recolección de elementos (Default o Forced) o si será optimizada (Optimized).

Excepciones

ArgumentOutOfRangeException

generation no es válido.

O bien

mode no es uno de los valores de GCCollectionMode .

Ejemplos

En el ejemplo siguiente se fuerza una recolección de elementos no utilizados para los objetos de generación 2 con la Optimized configuración .

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

Comentarios

Use el mode parámetro para especificar si la recolección de elementos no utilizados debe producirse inmediatamente o solo si el tiempo es óptimo para reclamar objetos. El uso de este método no garantiza que se recupere toda la memoria inaccesible de la generación especificada.

Para ajustar la intrusión de la recolección de elementos no utilizados durante períodos críticos en la aplicación, establezca la LatencyMode propiedad .

El recolector de elementos no utilizados no recopila objetos con un número de generación superior al especificado por el generation parámetro . Utilice la MaxGeneration propiedad para determinar el valor máximo válido de generation.

Para que el recolector de elementos no utilizados tenga en cuenta todos los objetos independientemente de su generación, use la versión de este método que no toma ningún parámetro.

Para que el recolector de elementos no utilizados recupere objetos hasta una generación especificada de objetos, use la sobrecarga del GC.Collect(Int32) método . Al especificar la generación máxima, se recopilan todos los objetos.

Consulte también

Se aplica a

Collect(Int32, GCCollectionMode, Boolean)

Source:
GC.CoreCLR.cs
Source:
GC.CoreCLR.cs
Source:
GC.CoreCLR.cs

Fuerza una recolección de elementos no utilizados de generación 0 en una generación especificada, en un momento especificado por un valor de GCCollectionMode, con un valor que especifica si la recolección debe ser de bloqueo.

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)

Parámetros

generation
Int32

El número de la generación más antigua de elementos no usados para recolectar.

mode
GCCollectionMode

Un valor de enumeración que especifica si se fuerza la recolección de elementos (Default o Forced) o si será optimizada (Optimized).

blocking
Boolean

true para realizar una recolección de elementos no utilizados de bloqueo; false para realizar una recolección de elementos no utilizados en segundo plano cuando sea posible.

Excepciones

ArgumentOutOfRangeException

generation no es válido.

O bien

mode no es uno de los valores de GCCollectionMode .

Comentarios

En la tabla siguiente se resume la interacción de los mode parámetros y blocking :

mode blocking es true blocking es false
Forced o Default Se realiza una recolección de bloqueo lo antes posible. Si una colección en segundo plano está en curso y generation es 0 o 1, el Collect(Int32, GCCollectionMode, Boolean) método desencadena inmediatamente una colección de bloqueo y devuelve cuando finaliza la colección. Si una colección en segundo plano está en curso y generation es 2, el método espera hasta que finaliza la colección en segundo plano, desencadena una colección de bloqueo de generación 2 y, a continuación, devuelve. Se realiza una recolección lo antes posible. El método Collect(Int32, GCCollectionMode, Boolean) solicita una colección en segundo plano, pero esto no se garantiza; puede que aún se realice una colección de bloqueo, dependiendo de las circunstancias. Si una colección en segundo plano ya está en curso, el método vuelve inmediatamente.
Optimized Se puede realizar una recolección de bloqueo, dependiendo del estado del recolector de elementos no utilizados y del parámetro generation. El recolector de elementos no utilizados intenta proporcionar un rendimiento óptimo. Se puede realizar una recolección, según el estado del recolector de elementos no utilizados. El método Collect(Int32, GCCollectionMode, Boolean) solicita una colección en segundo plano, pero esto no se garantiza; puede que aún se realice una colección de bloqueo, dependiendo de las circunstancias. El recolector de elementos no utilizados intenta proporcionar un rendimiento óptimo. Si una colección en segundo plano ya está en curso, el método vuelve inmediatamente.

Si una llamada al Collect(Int32, GCCollectionMode, Boolean) método realiza una recolección completa de elementos no utilizados de bloqueo, también puede compactar el montón de objetos grandes estableciendo la GCSettings.LargeObjectHeapCompactionMode propiedad GCLargeObjectHeapCompactionMode.CompactOnce en antes de llamar al Collect método .

Se aplica a

Collect(Int32, GCCollectionMode, Boolean, Boolean)

Source:
GC.CoreCLR.cs
Source:
GC.CoreCLR.cs
Source:
GC.CoreCLR.cs

Fuerza una recolección de elementos no utilizados de generación 0 en una generación especificada, en un momento especificado por un valor de GCCollectionMode, con valores que especifican si la recolección debe ser de bloqueo y compactante.

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)

Parámetros

generation
Int32

El número de la generación más antigua de elementos no usados para recolectar.

mode
GCCollectionMode

Un valor de enumeración que especifica si se fuerza la recolección de elementos (Default o Forced) o si será optimizada (Optimized).

blocking
Boolean

true para realizar una recolección de elementos no utilizados de bloqueo; false para realizar una recolección de elementos no utilizados en segundo plano cuando sea posible.

compacting
Boolean

true para compactar el montón de objetos pequeños; false solo para limpiar.

Comentarios

Si blocking es false, el GC decide si se debe realizar un fondo o una recolección de elementos no utilizados de bloqueo. Si compacting es true, realiza una recolección de elementos no utilizados de bloqueo.

Si compacting es true, el tiempo de ejecución compacta el montón de objetos pequeños (SOH). El montón de objetos grandes (LOH) no se compacta a menos que la GCSettings.LargeObjectHeapCompactionMode propiedad esté establecida GCLargeObjectHeapCompactionMode.CompactOnceen . Tenga en cuenta que esto incluye todo el bloqueo de recolecciones de elementos no utilizados, no solo de bloqueo total de recolecciones de elementos no utilizados.

Puede llamar al Collect(Int32, GCCollectionMode, Boolean, Boolean) método para reducir el montón administrado al tamaño más pequeño posible, como se muestra en el fragmento de código siguiente.

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)

Especificar true para el compacting argumento garantiza una recolección de elementos no utilizados de bloqueo completo y compactado. Establecer la GCSettings.LargeObjectHeapCompactionMode propiedad en GCLargeObjectHeapCompactionMode.CompactOnce garantiza que se compactan tanto loH como SOH.

Se aplica a