Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Clase OutOfMemoryException

 

Excepción que se produce cuando no hay suficiente memoria para continuar con la ejecución de un programa.

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

System.Object
  System.Exception
    System.SystemException
      System.OutOfMemoryException
        System.InsufficientMemoryException

[SerializableAttribute]
[ComVisibleAttribute(true)]
public class OutOfMemoryException : SystemException

NombreDescripción
System_CAPS_pubmethodOutOfMemoryException()

Inicializa una nueva instancia de la clase OutOfMemoryException.

System_CAPS_protmethodOutOfMemoryException(SerializationInfo, StreamingContext)

Inicializa una nueva instancia de la clase OutOfMemoryException con datos serializados.

System_CAPS_pubmethodOutOfMemoryException(String)

Inicializa una nueva instancia de la clase OutOfMemoryException con el mensaje de error especificado.

System_CAPS_pubmethodOutOfMemoryException(String, Exception)

Inicializa una nueva instancia de la clase OutOfMemoryException con el mensaje de error especificado y una referencia a la excepción interna que representa la causa de esta excepción.

NombreDescripción
System_CAPS_pubpropertyData

Obtiene una colección de pares clave-valor que proporcionan más información definida por el usuario sobre la excepción.(Heredado de Exception).

System_CAPS_pubpropertyHelpLink

Obtiene o establece un vínculo al archivo de ayuda asociado a esta excepción.(Heredado de Exception).

System_CAPS_pubpropertyHResult

Obtiene o establece HRESULT, un valor numérico codificado que se asigna a una excepción específica.(Heredado de Exception).

System_CAPS_pubpropertyInnerException

Obtiene la instancia Exception que produjo la excepción actual.(Heredado de Exception).

System_CAPS_pubpropertyMessage

Obtiene un mensaje que describe la excepción actual.(Heredado de Exception).

System_CAPS_pubpropertySource

Devuelve o establece el nombre de la aplicación o del objeto que generó el error.(Heredado de Exception).

System_CAPS_pubpropertyStackTrace

Obtiene una representación de cadena de los marcos inmediatos en la pila de llamadas.(Heredado de Exception).

System_CAPS_pubpropertyTargetSite

Obtiene el método que produjo la excepción actual.(Heredado de Exception).

NombreDescripción
System_CAPS_pubmethodEquals(Object)

Determina si el objeto especificado es igual al objeto actual.(Heredado de Object).

System_CAPS_protmethodFinalize()

Permite que un objeto intente liberar recursos y realizar otras operaciones de limpieza antes de ser reclamado por el recolector de basura. (Heredado de Object).

System_CAPS_pubmethodGetBaseException()

Cuando se invalida en una clase derivada, devuelve la clase Exception que representa la causa principal de una o más excepciones posteriores.(Heredado de Exception).

System_CAPS_pubmethodGetHashCode()

Sirve como la función hash predeterminada.(Heredado de Object).

System_CAPS_pubmethodGetObjectData(SerializationInfo, StreamingContext)

Cuando se invalida en una clase derivada, establece SerializationInfo con información sobre la excepción.(Heredado de Exception).

System_CAPS_pubmethodGetType()

Obtiene el tipo en tiempo de ejecución de la instancia actual.(Heredado de Exception).

System_CAPS_protmethodMemberwiseClone()

Crea una copia superficial del Object actual.(Heredado de Object).

System_CAPS_pubmethodToString()

Crea y devuelve una representación de cadena de la excepción actual.(Heredado de Exception).

NombreDescripción
System_CAPS_proteventSerializeObjectState

Ocurre cuando una excepción se serializa para crear un objeto de estado de excepción que contenga datos serializados sobre la excepción.(Heredado de Exception).

Un OutOfMemoryException excepción tiene dos causas principales:

  • Está intentando ampliar un StringBuilder objeto más allá de la longitud definida por su StringBuilder.MaxCapacity propiedad.

  • Common language runtime no puede asignar suficiente memoria contigua para realizar correctamente una operación. Se puede producir esta excepción por cualquier llamada de asignación o un método de propiedad que requiere una asignación de memoria. Para obtener más información sobre la causa de la OutOfMemoryException excepción, vea "Out of Memory" Does Not Refer to Physical Memory.

    Este tipo de OutOfMemoryException excepción representa un error catastrófico. Si opta por controlar la excepción, debe incluir un catch bloque que llama el Environment.FailFast método para finalizar la aplicación y agregue una entrada al registro de eventos del sistema, como en el ejemplo siguiente se hace.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          try {
             // Outer block to handle any unexpected exceptions.
             try {
                string s = "This";
                s = s.Insert(2, "is ");
    
                // Throw an OutOfMemoryException exception.
                throw new OutOfMemoryException();
             }
             catch (ArgumentException) {
                Console.WriteLine("ArgumentException in String.Insert");
             }
    
             // Execute program logic.
          }
          catch (OutOfMemoryException e) {
             Console.WriteLine("Terminating application unexpectedly...");
             Environment.FailFast(String.Format("Out of Memory: {0}",
                                                e.Message));
          }
       }
    }
    // The example displays the following output:
    //        Terminating application unexpectedly...
    

Algunas de las condiciones en las que se produce la excepción y las acciones que puede realizar para eliminar incluyen los siguientes:

Se está llamando a la StringBuilder.Insert método.

Está intentando aumentar la longitud de un StringBuilder objeto más allá del tamaño especificado por su StringBuilder.MaxCapacity propiedad. En el ejemplo siguiente se muestra la OutOfMemoryException excepción producida por una llamada a la StringBuilder.Insert(Int32, String, Int32) método cuando el ejemplo se intenta insertar una cadena que puede provocar que el objeto Length propiedad supere su capacidad máxima.

using System;
using System.Text;

public class Example
{
   public static void Main()
   {
      StringBuilder sb = new StringBuilder(15, 15);
      sb.Append("Substring #1 ");
      try {
         sb.Insert(0, "Substring #2 ", 1);
      }
      catch (OutOfMemoryException e) {
         Console.WriteLine("Out of Memory: {0}", e.Message);
      }
   }
}
// The example displays the following output:
//    Out of Memory: Insufficient memory to continue the execution of the program.

Puede realizar una de las siguientes acciones para solucionar el error:

La aplicación se ejecuta como un proceso de 32 bits.

procesos de 32 bits pueden asignar un máximo de 2GB de memoria de modo de usuario virtual en los sistemas de 32 bits y 4GB de memoria de modo de usuario virtual en los sistemas de 64 bits. Esto puede que sea más difícil para common language runtime asignar memoria contigua suficiente cuando se necesita una asignación grande. En cambio, los procesos de 64 bits pueden asignar hasta 8TB de memoria virtual. Para resolver esta excepción, vuelva a compilar la aplicación que tenga como destino una plataforma de 64 bits. Para obtener información sobre plataformas específicas en Visual Studio de destino, consulte Cómo: Configurar proyectos para plataformas de destino.

La aplicación pierde recursos no administrados

Aunque el recolector de elementos no utilizados puede liberar memoria asignada a los tipos administrados, no administra la memoria asignada a los recursos no administrados como identificadores de sistema operativo (incluidos los identificadores de archivos, archivos asignados en memoria, canalizaciones, las claves del registro y controladores de espera) y bloques de memoria asignados directamente por llamadas a la API de Windows o mediante llamadas a funciones de asignación de memoria como malloc. Los tipos que consumen recursos no administrados que implementan el IDisposable interfaz.

Si va a consumir un tipo que usa recursos no administrados, debe asegurarse de llamar a su IDisposable.Dispose método cuando termine de usarlo. (Algunos tipos también implementan un Close método que es idéntico en función de para un Dispose método.) Para obtener más información, vea el tema Using Objects That Implement IDisposable.

Si ha creado un tipo que usa recursos no administrados, asegúrese de que ha implementado el patrón de Dispose y, si es necesario, proporciona un finalizador. Para obtener más información, consulte el Patrón de Dispose, Implementar un método Dispose, y Object.Finalize temas.

Está intentando crear una matriz grande en un proceso de 64 bits.

De forma predeterminada, common language runtime no permite solo objetos cuyo tamaño supera los 2GB. Para invalidar este comportamiento predeterminado, puede usar el archivo de configuración para habilitar matrices cuyo tamaño total supera los 2 GB.

Se trabaja con grandes conjuntos de datos (por ejemplo, matrices, colecciones ni conjuntos de datos de la base de datos) en la memoria.

Cuando las estructuras de datos o conjuntos de datos que residen en la memoria sea tan grandes que common language runtime es no se puede asignar suficiente memoria contigua para ellos, un OutOfMemoryException resultados de la excepción.

Para evitar la OutOfMemoryException excepciones, debe modificar la aplicación para que los datos con menos están residentes en memoria o los datos se dividen en segmentos que requieren la asignación de memoria menor. Por ejemplo:

  • Si va a recuperar todos los datos de una base de datos y, a continuación, filtrarlos en su aplicación para minimizar los recorridos y en el servidor, debe modificar las consultas para devolver sólo el subconjunto de datos que necesita la aplicación. Al trabajar con tablas de gran tamaño, varias consultas casi siempre son más eficaz que recuperar todos los datos en una sola tabla y, a continuación, la manipulación.

  • Si va a ejecutar las consultas que los usuarios crear dinámicamente, debe asegurarse de que se limita el número de registros devueltos por la consulta.

  • Si está utilizando matrices de gran tamaño u otra colección de objetos cuyos resultados de tamaño en un OutOfMemoryException excepción, debe modificar la aplicación para que funcione de los datos en subconjuntos, en lugar de trabajar con ellos a la vez.

En el ejemplo siguiente se obtiene una matriz que consta de 200 millones de valores de punto flotante y, a continuación, calcula su Media. El resultado del ejemplo muestra que, dado que el ejemplo almacena toda la matriz en la memoria antes de que calcula la media, un OutOfMemoryException es se produce.

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      Double[] values = GetData();
      // Compute mean.
      Console.WriteLine("Sample mean: {0}, N = {1}",
                        GetMean(values), values.Length);
   }

   private static Double[] GetData()
   {
      Random rnd = new Random();
      List<Double> values = new List<Double>();
      for (int ctr = 1; ctr <= 200000000; ctr++) {
         values.Add(rnd.NextDouble());
         if (ctr % 10000000 == 0)
            Console.WriteLine("Retrieved {0:N0} items of data.",
                              ctr);
      }
      return values.ToArray();
   }

   private static Double GetMean(Double[] values)
   {
      Double sum = 0;
      foreach (var value in values)
         sum += value;

      return sum / values.Length;
   }
}
// The example displays output like the following:
//    Retrieved 10,000,000 items of data.
//    Retrieved 20,000,000 items of data.
//    Retrieved 30,000,000 items of data.
//    Retrieved 40,000,000 items of data.
//    Retrieved 50,000,000 items of data.
//    Retrieved 60,000,000 items of data.
//    Retrieved 70,000,000 items of data.
//    Retrieved 80,000,000 items of data.
//    Retrieved 90,000,000 items of data.
//    Retrieved 100,000,000 items of data.
//    Retrieved 110,000,000 items of data.
//    Retrieved 120,000,000 items of data.
//    Retrieved 130,000,000 items of data.
//
//    Unhandled Exception: OutOfMemoryException.

En el ejemplo siguiente se elimina el OutOfMemoryException excepción al procesar los datos de entrada sin almacenar todo el conjunto de datos en memoria, serializar los datos en un archivo si es necesario para permitir un procesamiento posterior (estas líneas se incluyen entre comentarios en el ejemplo, puesto que en este caso que generan un archivo cuyo tamaño es mayor que 1 GB) y devuelve el promedio calculado y el número de casos a la rutina que realiza la llamada.

using System;
using System.IO;

public class Example
{
   public static void Main()
   {
      Tuple<Double, long> result = GetResult();
      Console.WriteLine("Sample mean: {0}, N = {1:N0}",
                        result.Item1, result.Item2);
   }

   private static Tuple<Double, long> GetResult()
   {
      int chunkSize = 50000000;
      int nToGet = 200000000;
      Random rnd = new Random();
      // FileStream fs = new FileStream(@".\data.bin", FileMode.Create);
      // BinaryWriter bin = new BinaryWriter(fs);
      // bin.Write((int)0);
      int n = 0;
      Double sum = 0;
      for (int outer = 0;
           outer <= ((int) Math.Ceiling(nToGet * 1.0 / chunkSize) - 1);
           outer++) {
         for (int inner = 0;
              inner <= Math.Min(nToGet - n - 1, chunkSize - 1);
              inner++) {
            Double value = rnd.NextDouble();
            sum += value;
            n++;
            // bin.Write(value);
         }
      }
      // bin.Seek(0, SeekOrigin.Begin);
      // bin.Write(n);
      // bin.Close();
      return new Tuple<Double, long>(sum/n, n);
   }
}
// The example displays output like the following:
//    Sample mean: 0.500022771458399, N = 200,000,000
Repetidamente va a concatenar cadenas de gran tamaño.

Dado que las cadenas son inmutables, cada operación de concatenación de cadenas crea una nueva cadena. El impacto de las cadenas pequeñas o para un pequeño número de operaciones de concatenación es insignificante. Pero para cadenas de gran tamaño o un gran número de operaciones de concatenación, concatenación de cadenas puede conducir a un gran número de asignaciones de memoria y la fragmentación de memoria, un rendimiento bajo y posiblemente OutOfMemoryException excepciones.

Cuando la concatenación de cadenas de gran tamaño o realizar un gran número de operaciones de concatenación, debe usar el StringBuilder clase en lugar de la String clase. Cuando haya terminado de manipular la cadena, convertir la StringBuilder instancia en una cadena mediante una llamada a la StringBuilder.ToString método.

Anclar un gran número de objetos en memoria.

Anclar un gran número de objetos en la memoria durante largos períodos puede dificultar el recolector de elementos no utilizados asignar bloques de memoria contiguas. Si se ancló un gran número de objetos en memoria, por ejemplo mediante el uso de la fixed instrucción en C# o mediante una llamada a la GCHandle.Alloc(Object, GCHandleType) método con un tipo de identificador de GCHandleType.Pinned, puede hacer lo siguiente a la dirección el OutOfMemoryException excepción.

  • Evaluar si realmente necesita cada objeto fijarse,

  • Asegúrese de que cada objeto está anclado tan pronto como sea posible.

  • Asegúrese de que cada llamada a la GCHandle.Alloc(Object, GCHandleType) método en la memoria del pin tiene una llamada correspondiente a la GCHandle.Free método Desanclar esa memoria.

El siguiente Microsoft intermedias instrucciones (MSIL) producen un OutOfMemoryException excepción:

OutOfMemoryExceptionusa el valor HRESULT COR_E_OUTOFMEMORY, que tiene el valor 0x8007000E.

Para obtener una lista de valores de propiedad iniciales para una instancia de OutOfMemoryException, consulte el OutOfMemoryException constructores.

System_CAPS_noteNota

El valor de los heredados Data propiedad es siempre null.

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 1.1
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Windows Phone
Disponible desde 8.1

Cualquier miembro ( Compartido en Visual Basic) estático público de este tipo es seguro para subprocesos. No se garantiza que los miembros de instancia sean seguros para subprocesos.

Volver al principio
Mostrar: