OutOfMemoryException OutOfMemoryException OutOfMemoryException OutOfMemoryException Class

Definición

Excepción que se produce cuando no hay suficiente memoria para continuar con la ejecución de un programa.The exception that is thrown when there is not enough memory to continue the execution of a program.

public ref class OutOfMemoryException : SystemException
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public class OutOfMemoryException : SystemException
type OutOfMemoryException = class
    inherit SystemException
Public Class OutOfMemoryException
Inherits SystemException
Herencia
OutOfMemoryExceptionOutOfMemoryExceptionOutOfMemoryExceptionOutOfMemoryException
Derivado
Atributos

Comentarios

OutOfMemoryException usa el valor HRESULT COR_E_OUTOFMEMORY, que tiene el valor 0x8007000E.OutOfMemoryException uses the HRESULT COR_E_OUTOFMEMORY, which has the value 0x8007000E.

Para obtener una lista de valores de propiedad iniciales de una instancia de OutOfMemoryException, consulte el OutOfMemoryException constructores.For a list of initial property values for an instance of OutOfMemoryException, see the OutOfMemoryException constructors.

Nota

El valor de los heredados Data propiedad siempre es null.The value of the inherited Data property is always null.

Un OutOfMemoryException excepción tiene dos causas principales:An OutOfMemoryException exception has two major causes:

  • Está intentando ampliar un StringBuilder objeto más allá de la longitud definida por su StringBuilder.MaxCapacity propiedad.You are attempting to expand a StringBuilder object beyond the length defined by its StringBuilder.MaxCapacity property.

  • Common language runtime no puede asignar suficiente memoria contigua para realizar correctamente una operación.The common language runtime cannot allocate enough contiguous memory to successfully perform an operation. Cualquier llamada de método o la asignación de propiedad que requiere una asignación de memoria se puede producir esta excepción.This exception can be thrown by any property assignment or method call that requires a memory allocation. Para obtener más información sobre la causa de la OutOfMemoryException excepción, vea "memoria insuficiente" no hace referencia a la memoria física.For more information on the cause of the OutOfMemoryException exception, see "Out of Memory" Does Not Refer to Physical Memory.

    Este tipo de OutOfMemoryException excepción representa un error catastrófico.This type of OutOfMemoryException exception represents a catastrophic failure. Si decide controlar la excepción, se debe incluir un catch bloque que llama a la Environment.FailFast método para finalizar la aplicación y agregue una entrada al registro de eventos del sistema, como el siguiente ejemplo.If you choose to handle the exception, you should include a catch block that calls the Environment.FailFast method to terminate your app and add an entry to the system event log, as the following example does.

    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...
    
    Module Example
       Public Sub Main()
          Try
             ' Outer block to handle any unexpected exceptions.
             Try
                Dim s As String = "This"
                s = s.Insert(2, "is ")
    
                ' Throw an OutOfMemoryException exception.
                Throw New OutOfMemoryException()
             Catch e As ArgumentException
                Console.WriteLine("ArgumentException in String.Insert")
             End Try
             
             ' Execute program logic.
    
          Catch e As OutOfMemoryException
             Console.WriteLine("Terminating application unexpectedly...")
             Environment.FailFast(String.Format("Out of Memory: {0}",
                                                e.Message))
          End Try
       End Sub
    End Module
    ' 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 eliminarla incluyen lo siguiente:Some of the conditions under which the exception is thrown and the actions you can take to eliminate it include the following:

Se está llamando a la StringBuilder.Insert método.You are calling the StringBuilder.Insert method.

Intenta aumentar la longitud de un StringBuilder objeto más allá del tamaño especificado por su StringBuilder.MaxCapacity propiedad.You are attempting to increase the length of a StringBuilder object beyond the size specified by its StringBuilder.MaxCapacity property. El ejemplo siguiente ilustra 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 haría que el objeto Length propiedad supere su capacidad máxima.The following example illustrates the OutOfMemoryException exception thrown by a call to the StringBuilder.Insert(Int32, String, Int32) method when the example tries to insert a string that would cause the object's Length property to exceed its maximum capacity.

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.
Imports System.Text

Module Example
   Public Sub Main()
      Dim sb As New StringBuilder(15, 15)
      sb.Append("Substring #1 ")
      Try
         sb.Insert(0, "Substring #2 ", 1)
      Catch e As OutOfMemoryException
         Console.WriteLine("Out of Memory: {0}", e.Message)
      End Try
   End Sub
End Module
' The example displays the following output:
'   Out of Memory: Insufficient memory to continue the execution of the program.

Puede hacer cualquiera de las siguientes acciones para solucionar el error:You can do either of the following to address the error:

La aplicación se ejecuta como un proceso de 32 bits.Your app runs as a 32-bit process.

los 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 virtual del modo de usuario en los sistemas de 64 bits.32-bit processes can allocate a maximum of 2GB of virtual user-mode memory on 32-bit systems, and 4GB of virtual user-mode memory on 64-bit systems. Esto puede hacer más difícil que common language runtime asignar suficiente memoria contigua cuando se necesita una asignación grande.This can make it more difficult for the common language runtime to allocate sufficient contiguous memory when a large allocation is needed. En cambio, los procesos de 64 bits pueden asignar hasta 8TB de memoria virtual.In contrast, 64-bit processes can allocate up to 8TB of virtual memory. Para solucionar esta excepción, vuelva a compilar la aplicación para una plataforma de 64 bits de destino.To address this exception, recompile your app to target a 64-bit platform. Para obtener información sobre como destino plataformas específicas en Visual Studio, vea Cómo: Configurar proyectos para plataformas de destino.For information on targeting specific platforms in Visual Studio, see How to: Configure Projects to Target Platforms.

La aplicación pierde los recursos no administradosYour app is leaking unmanaged resources

Aunque el recolector de elementos no utilizados es capaz de liberar memoria asignada a los tipos administrados, no administra la memoria asignada a los recursos no administrados, como sistema operativo controla (incluidos los identificadores de archivos, archivos asignados a memoria, canalizaciones, las claves del registro y los identificadores de espera) y bloques de memoria asignados directamente por llamadas de API de Windows o mediante llamadas a funciones de asignación de memoria como malloc.Although the garbage collector is able to free memory allocated to managed types, it does not manage memory allocated to unmanaged resources such as operating system handles (including handles to files, memory-mapped files, pipes, registry keys, and wait handles) and memory blocks allocated directly by Windows API calls or by calls to memory allocation functions such as malloc. Los tipos que consumen recursos no administrados implementan la IDisposable interfaz.Types that consume unmanaged resources implement the IDisposable interface.

Si va a consumir un tipo que usa recursos no administrados, debe asegurarse de llamar a su IDisposable.Dispose método cuando haya terminado de usarlo.If you are consuming a type that uses unmanaged resources, you should be sure to call its IDisposable.Dispose method when you have finished using it. (Algunos tipos también implementan un Close método que es idéntico en la función en un Dispose método.) Para obtener más información, consulte el utilizando los objetos que implementan IDisposable tema.(Some types also implement a Close method that is identical in function to a Dispose method.) For more information, see the Using Objects That Implement IDisposable topic.

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.If you have created a type that uses unmanaged resources, make sure that you have implemented the Dispose pattern and, if necessary, supplied a finalizer. Para obtener más información, consulte implementar un método Dispose y Object.Finalize.For more information, see Implementing a Dispose method and Object.Finalize.

Está intentando crear una matriz grande en un proceso de 64 bitsYou are attempting to create a large array in a 64-bit process

De forma predeterminada, en .NET Framework common language runtime no permite objetos únicos cuyo tamaño supere los 2GB.By default, the common language runtime in .NET Framework does not allow single objects whose size exceeds 2GB. Para invalidar este comportamiento predeterminado, puede usar el <gcAllowVeryLargeObjects > archivo de configuración para habilitar las matrices cuyo tamaño total supera los 2 GB.To override this default, you can use the <gcAllowVeryLargeObjects> configuration file setting to enable arrays whose total size exceeds 2 GB. En .NET Core, compatibilidad con matrices de mayor que 2 GB está habilitada de forma predeterminada.On .NET Core, support for arrays of greater than 2 GB is enabled by default.

Trabaja con grandes conjuntos de datos (por ejemplo, matrices, colecciones o conjuntos de datos de la base de datos) en la memoria.You are working with very large sets of data (such as arrays, collections, or database data sets) in memory.

Cuando las estructuras de datos o conjuntos de datos que residen en la memoria dejan de ser tan grandes que common language runtime no se puede asignar suficiente memoria contigua para ellos, un OutOfMemoryException resultados de la excepción.When data structures or data sets that reside in memory become so large that the common language runtime is unable to allocate enough contiguous memory for them, an OutOfMemoryException exception results.

Para evitar la OutOfMemoryException excepciones, debe modificar la aplicación de modo que menos datos residentes en memoria, o los datos se dividen en segmentos que requieren asignaciones de memoria menor.To prevent the OutOfMemoryException exceptions, you must modify your application so that less data is resident in memory, or the data is divided into segments that require smaller memory allocations. Por ejemplo:For example:

  • Si está recuperando todos los datos de una base de datos y, a continuación, filtrarla en la aplicación para minimizar los viajes al servidor, debe modificar las consultas para devolver solo el subconjunto de datos que necesita la aplicación.If you are retrieving all of the data from a database and then filtering it in your app to minimize trips to the server, you should modify your queries to return only the subset of data that your app needs. Al trabajar con tablas de gran tamaño, varias consultas casi siempre son mucho más eficaz que recuperar todos los datos en una sola tabla y, a continuación, manipularlo.When working with large tables, multiple queries are almost always more efficient than retrieving all of the data in a single table and then manipulating it.

  • 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.If you are executing queries that users create dynamically, you should ensure that the number of records returned by the query is limited.

  • Si usa matrices de gran tamaño o en otra colección de objetos cuyos resultados de tamaño en un OutOfMemoryException excepción, debe modificar la aplicación funcionan los datos en subconjuntos en lugar de trabajar con ellos a la vez.If you are using large arrays or other collection objects whose size results in an OutOfMemoryException exception, you should modify your application to work the data in subsets rather than to work with it all at once.

El ejemplo siguiente obtiene una matriz que consta de 200 millones de valores de punto flotante y, a continuación, calcula su Media.The following example gets a array that consists of 200 million floating-point values and then calculates their mean. 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 se produce.The output from the example shows that, because the example stores the entire array in memory before it calculates the mean, an OutOfMemoryException is thrown.

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.
Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim values() As Double = GetData()
      ' Compute mean.
      Console.WriteLine("Sample mean: {0}, N = {1}",
                        GetMean(values), values.Length)
   End Sub
   
   Private Function GetData() As Double()
      Dim rnd As New Random()
      Dim values As New List(Of Double)()
      For ctr As Integer = 1 To 200000000
         values.Add(rnd.NextDouble)
         If ctr Mod 10000000 = 0 Then
            Console.WriteLine("Retrieved {0:N0} items of data.",
                              ctr)
         End If
      Next
      Return values.ToArray()
   End Function
   
   Private Function GetMean(values() As Double) As Double
      Dim sum As Double = 0
      For Each value In values
         sum += value
      Next
      Return sum / values.Length
   End Function
End Module
' 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.

El ejemplo siguiente se elimina el OutOfMemoryException excepción al procesar los datos entrantes sin almacenar todo el conjunto de datos en memoria, serializar los datos en un archivo si es necesario para permitir el procesamiento posterior (estas líneas se comentan en el ejemplo, Dado que en este caso genera 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.The following example eliminates the OutOfMemoryException exception by processing the incoming data without storing the entire data set in memory, serializing the data to a file if necessary to permit further processing (these lines are commented out in the example, since in this case they produce a file whose size is greater than 1GB), and returning the calculated mean and the number of cases to the calling routine.

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
Imports System.IO

Module Example
   Public Sub Main()
      Dim result As Tuple(Of Double, Long) = GetResult()
      Console.WriteLine("Sample mean: {0}, N = {1:N0}",
                        result.Item1, result.Item2)
   End Sub

   Private Function GetResult As Tuple(Of Double, Long)
      Dim chunkSize As Integer = 50000000
      Dim nToGet As Integer = 200000000
      Dim rnd As New Random()
'       Dim fs As New FileStream(".\data.bin", FileMode.Create)
'       Dim bin As New BinaryWriter(fs)
'       bin.Write(CInt(0))
      Dim n As Integer
      Dim sum As Double
      For outer As Integer = 0 To CInt(Math.Ceiling(nToGet/chunkSize) - 1)
         For inner = 0 To Math.Min(nToGet - n - 1, chunkSize - 1)
            Dim value As Double = rnd.NextDouble()
            sum += value
            n += 1
'            bin.Write(value)
         Next
      Next
'       bin.Seek(0, SeekOrigin.Begin)
'       bin.Write(n)
'       bin.Close()
      Return New Tuple(Of Double, Long)(sum/n, n)
   End Function
End Module
' The example displays output like the following:
'   Sample mean: 0.500022771458399, N = 200,000,000

Cadenas de gran tamaño se concatenan varias veces.You are repeatedly concatenating large strings.

Dado que las cadenas son inmutables, cada operación de concatenación de cadenas crea una nueva cadena.Because strings are immutable, each string concatenation operation creates a new string. El impacto para las cadenas pequeñas o para un pequeño número de operaciones de concatenación es insignificante.The impact for small strings, or for a small number of concatenation operations, is negligible. Pero o un gran número de operaciones de concatenación de cadenas de gran tamaño, concatenación de cadenas puede dar lugar a un gran número de asignaciones de memoria y la fragmentación de memoria, un rendimiento deficiente y posiblemente OutOfMemoryException excepciones.But for large strings or a very large number of concatenation operations, string concatenation can lead to a large number of memory allocations and memory fragmentation, poor performance, and possibly OutOfMemoryException exceptions.

Al concatenar cadenas grandes o realizando un gran número de operaciones de concatenación, debe usar el StringBuilder clase en lugar de la String clase.When concatenating large strings or performing a large number of concatenation operations, you should use the StringBuilder class instead of the String class. Cuando haya terminado de manipular las cadenas, convierta el StringBuilder instancia en una cadena mediante una llamada a la StringBuilder.ToString método.When you have finished manipulating the string, convert the StringBuilder instance to a string by calling the StringBuilder.ToString method.

Anclar un gran número de objetos en memoria.You pin a large number of objects in memory.

Fijación de un gran número de objetos en memoria durante largos períodos puede dificultar el recolector de elementos no utilizados asignar bloques contiguos de memoria.Pinning a large number of objects in memory for long periods can make it difficult for the garbage collector to allocate contiguous blocks of memory. Si ha anclado 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 del OutOfMemoryException excepción.If you've pinned a large number of objects in memory, for example by using the fixed statement in C# or by calling the GCHandle.Alloc(Object, GCHandleType) method with a handle type of GCHandleType.Pinned, you can do the following to address the OutOfMemoryException exception.

  • Evaluar si realmente necesita cada objeto quede anclada,Evaluate whether each object really needs to be pinned,

  • Asegúrese de que cada objeto está desanclado tan pronto como sea posible.Ensure that each object is unpinned as soon as possible.

  • Asegúrese de que cada llamada a la GCHandle.Alloc(Object, GCHandleType) método a la memoria del pin tiene una llamada correspondiente a la GCHandle.Free método Desanclar esa memoria.Make sure that each call to the GCHandle.Alloc(Object, GCHandleType) method to pin memory has a corresponding call to the GCHandle.Free method to unpin that memory.

Microsoft siguiente instrucciones intermedias (MSIL) producen un OutOfMemoryException excepción:The following Microsoft intermediate (MSIL) instructions throw an OutOfMemoryException exception:

Constructores

OutOfMemoryException() OutOfMemoryException() OutOfMemoryException() OutOfMemoryException()

Inicializa una nueva instancia de la clase OutOfMemoryException.Initializes a new instance of the OutOfMemoryException class.

OutOfMemoryException(SerializationInfo, StreamingContext) OutOfMemoryException(SerializationInfo, StreamingContext) OutOfMemoryException(SerializationInfo, StreamingContext) OutOfMemoryException(SerializationInfo, StreamingContext)

Inicializa una nueva instancia de la clase OutOfMemoryException con datos serializados.Initializes a new instance of the OutOfMemoryException class with serialized data.

OutOfMemoryException(String) OutOfMemoryException(String) OutOfMemoryException(String) OutOfMemoryException(String)

Inicializa una nueva instancia de la clase OutOfMemoryException con el mensaje de error especificado.Initializes a new instance of the OutOfMemoryException class with a specified error message.

OutOfMemoryException(String, Exception) OutOfMemoryException(String, Exception) OutOfMemoryException(String, Exception) OutOfMemoryException(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.Initializes a new instance of the OutOfMemoryException class with a specified error message and a reference to the inner exception that is the cause of this exception.

Propiedades

Data Data Data Data

Obtiene una colección de pares clave-valor que proporcionan más información definida por el usuario sobre la excepción.Gets a collection of key/value pairs that provide additional user-defined information about the exception.

(Inherited from Exception)
HelpLink HelpLink HelpLink HelpLink

Obtiene o establece un vínculo al archivo de ayuda asociado a esta excepción.Gets or sets a link to the help file associated with this exception.

(Inherited from Exception)
HResult HResult HResult HResult

Obtiene o establece HRESULT, un valor numérico codificado que se asigna a una excepción específica.Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception.

(Inherited from Exception)
InnerException InnerException InnerException InnerException

Obtiene la instancia Exception que produjo la excepción actual.Gets the Exception instance that caused the current exception.

(Inherited from Exception)
Message Message Message Message

Obtiene un mensaje que describe la excepción actual.Gets a message that describes the current exception.

(Inherited from Exception)
Source Source Source Source

Devuelve o establece el nombre de la aplicación o del objeto que generó el error.Gets or sets the name of the application or the object that causes the error.

(Inherited from Exception)
StackTrace StackTrace StackTrace StackTrace

Obtiene una representación de cadena de los marcos inmediatos en la pila de llamadas.Gets a string representation of the immediate frames on the call stack.

(Inherited from Exception)
TargetSite TargetSite TargetSite TargetSite

Obtiene el método que produjo la excepción actual.Gets the method that throws the current exception.

(Inherited from Exception)

Métodos

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina si el objeto especificado es igual al objeto actual.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetBaseException() GetBaseException() GetBaseException() GetBaseException()

Cuando se reemplaza en una clase derivada, devuelve la clase Exception que representa la causa principal de una o más excepciones posteriores.When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions.

(Inherited from Exception)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Sirve como la función hash predeterminada.Serves as the default hash function.

(Inherited from Object)
GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext)

Cuando se reemplaza en una clase derivada, establece SerializationInfo con información sobre la excepción.When overridden in a derived class, sets the SerializationInfo with information about the exception.

(Inherited from Exception)
GetType() GetType() GetType() GetType()

Obtiene el tipo de tiempo de ejecución de la instancia actual.Gets the runtime type of the current instance.

(Inherited from Exception)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficial del objeto Object actual.Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

Crea y devuelve una representación de cadena de la excepción actual.Creates and returns a string representation of the current exception.

(Inherited from Exception)

Eventos

SerializeObjectState SerializeObjectState SerializeObjectState SerializeObjectState

Ocurre cuando una excepción se serializa para crear un objeto de estado de excepción que contenga datos serializados sobre la excepción.Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception.

(Inherited from Exception)

Se aplica a

Consulte también: