Exportar (0) Imprimir
Expandir todo

GC (Clase)

Controla el recolector de elementos no utilizados del sistema, un servicio que reclama de forma automática la memoria que no se utiliza.

Espacio de nombres: System
Ensamblado: mscorlib (en mscorlib.dll)

public static class GC
public final class GC
public final class GC

Los métodos de esta clase influyen en el momento en que se realiza la recolección de elementos no utilizados de un objeto y en el momento en que se liberan los recursos asignados por un objeto. Las propiedades de esta clase proporcionan información sobre la cantidad de memoria total disponible en el sistema y la categoría de edad, o generación, de la memoria asignada a un objeto.

El recolector de elementos no utilizados realiza un seguimiento de los objetos asignados en la memoria administrada, y los reclama. De forma periódica, el recolector de elementos no utilizados reclama la memoria asignada a los objetos para los que no existen referencias válidas. La recolección de elementos no utilizados se produce de forma automática, cuando una solicitud de memoria no puede satisfacerse utilizando la memoria libre que queda disponible. Una aplicación también puede provocar la recolección de elementos no utilizados mediante el método Collect.

La recolección de elementos no utilizados consta de los siguientes pasos:

  1. El recolector de elementos no utilizados busca los objetos administrados a los que se hace referencia en el código administrado.

  2. El recolector de elementos no utilizados intenta finalizar los objetos a los que no se hace referencia.

  3. El recolector de elementos no utilizados libera los objetos a los que no se hace referencia y reclama la memoria utilizada por estos objetos.

Durante la recolección de elementos no utilizados, el recolector no liberará un objeto si encuentra una o varias referencias al mismo en el código administrado. El recolector de elementos no utilizados no reconoce, sin embargo, las referencias a objetos desde el código no administrado y puede liberar objetos que se estén utilizando exclusivamente en código no administrado, a menos que se le impida hacerlo de forma explícita. El método KeepAlive proporciona un mecanismo que impide que el recolector de elementos no utilizados recoja objetos que aún estén en uso en el código no administrado.

Salvo en el caso de las asignaciones de memoria administrada, las implementaciones del recolector de elementos no utilizados no incluyen información sobre los recursos mantenidos por un objeto, como los identificadores de archivo o las conexiones de base de datos. Cuando un tipo utiliza recursos no administrados que deben liberarse antes de que se reclamen las instancias del tipo, éste puede implementar un finalizador.

En la mayoría de los casos, los finalizadores se implementan reemplazando el método Object.Finalize; no obstante, los tipos escritos en C# o C++ implementan destructores, que los compiladores convierten en un reemplazo del método Object.Finalize. En la mayoría de los casos, si un objeto tiene un finalizador, el recolector de elementos no utilizados llama a dicho finalizador antes de liberar el objeto. Sin embargo, el recolector de elementos no utilizados no debe llamar a los finalizadores en todas las situaciones; por ejemplo, el método SuppressFinalize evita explícitamente que se llame a un finalizador. Además, el recolector de elementos no utilizados no tiene por qué utilizar un subproceso específico para finalizar objetos ni tampoco tiene por qué garantizar el orden en que se llama a los finalizadores para objetos que se hacen referencia mutuamente pero que sin embargo están disponibles para su recolección.

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

Aunque no es obligatorio, se recomienda que los recolectores de elementos no utilizados admitan la caducidad de objetos mediante el uso de generaciones. Una generación es una unidad de medida de la edad relativa de los objetos en la memoria. El número de generación o la edad de un objeto indica la generación a la que pertenece. Los objetos creados más recientemente forman parte de las últimas generaciones y tienen números de generación más bajos que los objetos creados en fases anteriores del período de duración de la aplicación. Los objetos de la generación más reciente pertenecen a la generación cero.

Notas para los implementadores Esta implementación del recolector de elementos no utilizados admite tres generaciones de objetos. MaxGeneration se utiliza para determinar el número de generación máximo que va a admitir el sistema. La edad de los objetos permite que las aplicaciones dirijan la recolección de elementos no utilizados a un conjunto específico de generaciones en lugar de hacer que el recolector de elementos no utilizados evalúe todas las generaciones.

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();
            }
        }
    }
}

package GCCollectIntExample; 

import System.* ;

class MyGCCollectClass
{
    private static final long maxGarbage = 1000;

    public static void main(String[] args)
    {
        MyGCCollectClass myGCCol = new MyGCCollectClass();

        // Determine the maximum number of generations the system
        // garbage collector currently supports.
        Console.WriteLine("The highest generation is {0}", 
            System.Convert.ToString(GC.get_MaxGeneration()));
        myGCCol.MakeSomeGarbage();

        // Determine which generation myGCCol object is stored in.
        Console.WriteLine("Generation: {0}", 
            System.Convert.ToString(GC.GetGeneration(myGCCol)));

        // Determine the best available approximation of the number 
        // of bytes currently allocated in managed memory.
        Console.WriteLine("Total Memory: {0}", 
            System.Convert.ToString(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}", 
            System.Convert.ToString(GC.GetGeneration(myGCCol)));
        Console.WriteLine("Total Memory: {0}", 
            System.Convert.ToString(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}", 
            System.Convert.ToString(GC.GetGeneration(myGCCol)));
        Console.WriteLine("Total Memory: {0}", 
            System.Convert.ToString(GC.GetTotalMemory(false)));
        Console.Read();
    } //main

    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();
        }
    } //MakeSomeGarbage
} //MyGCCollectClass

Los miembros estáticos públicos (Shared en Visual Basic) de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium, Windows Mobile para Pocket PC, Windows Mobile para Smartphone, Windows Server 2003, Windows XP Media Center, Windows XP Professional x64, Windows XP SP2, Windows XP Starter Edition

.NET Framework no admite todas las versiones de cada plataforma. Para obtener una lista de las versiones admitidas, vea Requisitos del sistema.

.NET Framework

Compatible con: 2.0, 1.1, 1.0

.NET Compact Framework

Compatible con: 2.0, 1.0

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft