GC Clase

Definición

public ref class GC abstract sealed

public ref class GC sealed

public static class GC

public sealed class GC

type GC = class

Public Class GC

Public NotInheritable Class GC

Herencia

Object

GC

Ejemplos

En el ejemplo siguiente se usan varios métodos gc para obtener información de generación y memoria sobre un bloque de objetos no utilizados e imprimirlo en la consola. A continuación, se recopilan los objetos no utilizados y se muestran los totales de memoria resultantes.

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

La GC clase controla el recolector de basura. El recolector de elementos no utilizados es un componente de Common Language Runtime que controla la asignación y liberación de la memoria administrada. Los métodos de esta clase influyen en cuándo se realiza la recolección de elementos no utilizados en un objeto y en cuándo los recursos asignados a un objeto se liberan. Las propiedades de esta clase proporcionan información sobre la cantidad total de memoria disponible en el sistema y la categoría de antigüedad, o generación, de memoria asignada a un objeto.

El recolector de basura realiza un seguimiento y recupera los objetos asignados en la memoria administrada. Periódicamente, el recolector de basura realiza la recolección de basura para reclamar la memoria asignada a los objetos para los que no hay referencias válidas. La recolección de elementos no utilizados se produce automáticamente cuando no se puede satisfacer una solicitud de memoria mediante la memoria libre disponible. Como alternativa, una aplicación puede forzar la recolección de basura usando el método Collect.

La recogida de basura consta de los siguientes pasos:

1. El recolector de elementos no utilizados busca objetos administrados a los que se hace referencia en código administrado.
2. El recolector de basura intenta finalizar los objetos a los que no se hace referencia.
3. El recolector de elementos no utilizados libera objetos a los que no se hace referencia y reclama su memoria.

Recursos no administrados

Durante una recolección, el recolector de basura no liberará un objeto si encuentra una o más referencias al objeto en código administrado. Sin embargo, el recolector de elementos no utilizados no reconoce referencias a un objeto de código no administrado y podría liberar objetos que se usan exclusivamente en código no administrado a menos que se impida explícitamente hacerlo. El KeepAlive método proporciona un mecanismo que impide que el recolector de basura recoja objetos que todavía están en uso en código no administrado.

Además de las asignaciones de memoria administradas, las implementaciones del recolector de elementos no utilizados no mantienen información sobre los recursos mantenidos por un objeto, como identificadores de archivo o conexiones de base de datos. Cuando un tipo usa recursos no administrados que se deben liberar antes de que se recuperen las instancias del tipo, el tipo puede implementar un finalizador.

En la mayoría de los casos, los finalizadores se implementan sobrescribiendo el método Object.Finalize; sin embargo, los tipos escritos en C# o C++ implementan destructores, que los compiladores convierten en una sobrescritura de Object.Finalize. En la mayoría de los casos, si un objeto tiene un finalizador, el recolector de elementos no utilizados lo llama antes de liberar el objeto. Sin embargo, no es necesario que el recolector de elementos no utilizados llame a finalizadores en todas las situaciones; por ejemplo, el método SuppressFinalize impide explícitamente que se llame al finalizador de un objeto. Además, el recolector de elementos no utilizados no está obligado a usar un subproceso específico para finalizar los objetos, ni a garantizar el orden en que se llaman a los finalizadores para los objetos que se referencian entre sí pero que, por lo demás, están disponibles para la recolección de elementos no utilizados.

En escenarios en los que se deben liberar recursos en un momento específico, las clases pueden implementar la IDisposable interfaz , que contiene el IDisposable.Dispose método que realiza tareas de limpieza y administración de recursos. Las clases que implementan Dispose deben especificar, como parte de su contrato de clase, si y cuándo los usuarios de la clase llaman al método para limpiar el objeto. El recolector de basura no llama al método Dispose de forma predeterminada; sin embargo, las implementaciones del método Dispose pueden llamar a métodos de la clase GC para personalizar el comportamiento de finalización del recolector de basura.

Para obtener más información sobre la finalización de objetos y el patrón dispose, vea Limpieza de recursos no administrados.

Envejecimiento y generaciones de objetos

El recolector de basura de Common Language Runtime soporta el envejecimiento de objetos usando generaciones. Una generación es una unidad de medida de la antigüedad relativa de los objetos en la memoria. El número de generación, o la antigüedad, de un objeto indica la generación a la que pertenece un objeto. Los objetos creados más recientemente forman parte de las generaciones más recientes y tienen números de generación inferiores a los objetos creados anteriormente en el ciclo de vida de la aplicación. Los objetos de la generación más reciente están en la generación 0. Esta implementación del recolector de elementos no utilizados admite tres generaciones de objetos, generaciones 0, 1 y 2. Puede recuperar el valor de la MaxGeneration propiedad para determinar el número máximo de generación admitido por el sistema.

El envejecimiento de objetos permite a las aplicaciones orientar la recolección de basura hacia ciertas generaciones específicas en lugar de exigir que el recolector evalúe todas las generaciones. Las sobrecargas del método Collect que incluyen un parámetro generation permiten especificar la generación más antigua que recogerá el recolector de elementos no utilizados.

Prohibir la recolección de basura

El recolector de elementos no utilizados admite un modo de latencia de región sin recolección de elementos no utilizados que se puede usar durante la ejecución de trayectorias críticas en las que la recolección de elementos no utilizados puede afectar negativamente al rendimiento de una aplicación. El modo de latencia de región sin GC requiere que especifique una cantidad de memoria que se puede asignar sin interferencias del recolector de elementos no utilizados. Si el tiempo de ejecución puede asignar esa memoria, el tiempo de ejecución no realizará una recolección de basura mientras se ejecuta el código en la ruta crítica.

Para definir el inicio de la ruta crítica de la región sin GC, debe llamar a una de las sobrecargas de TryStartNoGCRegion. Para especificar el final de su ruta de acceso crítica, llame al método EndNoGCRegion.

No se pueden anidar llamadas al método TryStartNoGCRegion y solo debe llamar al método EndNoGCRegion si el tiempo de ejecución no está actualmente en modo de latencia de región de GC. En otras palabras, no debe llamar a TryStartNoGCRegion varias veces (después de la primera llamada al método, las llamadas posteriores no tendrán éxito), y no debe esperar que las llamadas a EndNoGCRegion tengan éxito simplemente porque la primera llamada a TryStartNoGCRegion tuvo éxito.

Consulte también

• GCSettings
• Recolección de basura
• Fundamentos de la recolección de basura