OutOfMemoryException OutOfMemoryException OutOfMemoryException OutOfMemoryException Class

Definição

A exceção que é gerada quando não há memória suficiente para continuar a execução de um 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
Herança
OutOfMemoryExceptionOutOfMemoryExceptionOutOfMemoryExceptionOutOfMemoryException
Derivado
Atributos

Comentários

OutOfMemoryException usa o HRESULT COR_E_OUTOFMEMORY, que tem o valor 0x8007000E.OutOfMemoryException uses the HRESULT COR_E_OUTOFMEMORY, which has the value 0x8007000E.

Para obter uma lista de valores de propriedade inicial para uma instância do OutOfMemoryException, consulte o OutOfMemoryException construtores.For a list of initial property values for an instance of OutOfMemoryException, see the OutOfMemoryException constructors.

Observação

O valor da herdadas Data propriedade é sempre null.The value of the inherited Data property is always null.

Um OutOfMemoryException exceção tem duas causas principais:An OutOfMemoryException exception has two major causes:

  • Você está tentando executar expandir uma StringBuilder objeto além do comprimento definido pela sua StringBuilder.MaxCapacity propriedade.You are attempting to expand a StringBuilder object beyond the length defined by its StringBuilder.MaxCapacity property.

  • O common language runtime não é possível alocar memória contínua suficiente para executar com êxito uma operação.The common language runtime cannot allocate enough contiguous memory to successfully perform an operation. Essa exceção pode ser gerada por qualquer chamada de método ou atribuição de propriedade que exige uma alocação de memória.This exception can be thrown by any property assignment or method call that requires a memory allocation. Para obter mais informações sobre a causa do OutOfMemoryException exceção, consulte "memória insuficiente" não faz referência a memória física.For more information on the cause of the OutOfMemoryException exception, see "Out of Memory" Does Not Refer to Physical Memory.

    Esse tipo de OutOfMemoryException exceção representa uma falha catastrófica.This type of OutOfMemoryException exception represents a catastrophic failure. Se você optar por tratar a exceção, você deve incluir um catch bloco que chama o Environment.FailFast método para encerrar o aplicativo e adicionar uma entrada ao log de eventos do sistema, como o exemplo a seguir faz.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...
    

Algumas das condições sob as quais a exceção é lançada e as ações que você pode tomar para eliminá-lo incluem o seguinte:Some of the conditions under which the exception is thrown and the actions you can take to eliminate it include the following:

Você está chamando o StringBuilder.Insert método.You are calling the StringBuilder.Insert method.

Você está tentando aumentar o tamanho de um StringBuilder objeto além do tamanho especificado pelo seu StringBuilder.MaxCapacity propriedade.You are attempting to increase the length of a StringBuilder object beyond the size specified by its StringBuilder.MaxCapacity property. O exemplo a seguir ilustra a OutOfMemoryException exceção gerada por uma chamada para o StringBuilder.Insert(Int32, String, Int32) método quando o exemplo tenta inserir uma cadeia de caracteres que faria com que o objeto Length propriedade exceda sua capacidade 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.

Você pode fazer o seguinte para resolver o erro:You can do either of the following to address the error:

Seu aplicativo é executado como um processo de 32 bits.Your app runs as a 32-bit process.

processos de 32 bits podem alocar um máximo de 2GB de memória do modo de usuário virtual em sistemas de 32 bits e 4GB de memória em modo de usuário virtual em 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. Isso pode tornar mais difícil para o common language runtime alocar memória contínua suficiente quando uma alocação grande é necessária.This can make it more difficult for the common language runtime to allocate sufficient contiguous memory when a large allocation is needed. Em contraste, os processos de 64 bits podem alocar até 8TB de memória virtual.In contrast, 64-bit processes can allocate up to 8TB of virtual memory. Para resolver essa exceção, recompile o aplicativo para uma plataforma de 64 bits de destino.To address this exception, recompile your app to target a 64-bit platform. Para obter informações sobre direcionamento a plataformas específicas no Visual Studio, consulte como: Configurar projetos para plataformas de destino.For information on targeting specific platforms in Visual Studio, see How to: Configure Projects to Target Platforms.

Seu aplicativo esteja com vazamento de recursos não gerenciadosYour app is leaking unmanaged resources

Embora o coletor de lixo seja capaz de liberar a memória alocada para tipos gerenciados, ele não gerencia a memória alocada para recursos não gerenciados, como o sistema operacional trata (incluindo os identificadores de arquivos, arquivos mapeados na memória, pipes, chaves do registro e identificadores de espera) e blocos de memória alocados diretamente por chamadas à API do Windows ou por chamadas para funções de alocação de memória, 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. Tipos que consomem recursos não gerenciados implementam a IDisposable interface.Types that consume unmanaged resources implement the IDisposable interface.

Se você estiver consumindo um tipo que usa os recursos não gerenciados, você deve ter certeza chamar seu IDisposable.Dispose método quando você tiver terminado de usá-lo.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. (Alguns tipos também implementam uma Close método que é idêntico em função para um Dispose método.) Para obter mais informações, consulte o usando objetos que implementar IDisposable tópico.(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.

Se você tiver criado um tipo que usa os recursos não gerenciados, certifique-se de que você tiver implementado o padrão Dispose e, se necessário, fornecido um 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 obter mais informações, consulte implementando um método Dispose e Object.Finalize.For more information, see Implementing a Dispose method and Object.Finalize.

Você está tentando criar uma matriz grande em um processo de 64 bitsYou are attempting to create a large array in a 64-bit process

Por padrão, o common language runtime do .NET Framework não permite objetos únicos cujo tamanho excede 2GB.By default, the common language runtime in .NET Framework does not allow single objects whose size exceeds 2GB. Para substituir esse padrão, você pode usar o <gcAllowVeryLargeObjects > arquivo de configuração para habilitar matrizes cujo tamanho total exceder 2 GB.To override this default, you can use the <gcAllowVeryLargeObjects> configuration file setting to enable arrays whose total size exceeds 2 GB. No .NET Core, suporte para matrizes de mais de 2 GB é habilitado por padrão.On .NET Core, support for arrays of greater than 2 GB is enabled by default.

Você está trabalhando com grandes conjuntos de dados (como matrizes, coleções ou conjuntos de dados do banco de dados) na memória.You are working with very large sets of data (such as arrays, collections, or database data sets) in memory.

Quando as estruturas de dados ou conjuntos de dados que residem na memória se tornar muito grandes, que o common language runtime não é possível alocar memória contínua suficiente para eles, um OutOfMemoryException resultados de exceção.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 impedir que o OutOfMemoryException exceções, você deve modificar seu aplicativo para que menos dados seja residentes na memória, ou os dados são divididos em segmentos que exigem as alocações de memória menores.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 exemplo:For example:

  • Se você estiver recuperando todos os dados de um banco de dados e, em seguida, filtrá-lo em seu aplicativo para minimizar as viagens ao servidor, você deve modificar suas consultas para retornar somente o subconjunto de dados que seu aplicativo precisa.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. Ao trabalhar com tabelas grandes, várias consultas quase sempre são mais eficientes do que recuperar todos os dados em uma única tabela e, em seguida, manipulá-los.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.

  • Se você estiver executando consultas que os usuários criam dinamicamente, você deve garantir que o número de registros retornados pela consulta é limitado.If you are executing queries that users create dynamically, you should ensure that the number of records returned by the query is limited.

  • Se você estiver usando matrizes grandes ou outra coleção de objetos cujos resultados de tamanho em um OutOfMemoryException exceção, você deve modificar seu aplicativo para trabalhar os dados em subconjuntos em vez de trabalhar com eles ao mesmo tempo.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.

O exemplo a seguir obtém uma matriz que consiste em 200 milhões de valores de ponto flutuantes e, em seguida, calcula a média.The following example gets a array that consists of 200 million floating-point values and then calculates their mean. A saída do exemplo mostra que, como o exemplo armazena toda a matriz na memória antes de ele calcula a média, um OutOfMemoryException é gerada.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.

O exemplo a seguir elimina o OutOfMemoryException exceção processando os dados de entrada sem armazenar todo o conjunto de dados na memória, serializar os dados em um arquivo, se necessário, para permitir o processamento adicional (essas linhas são comentadas no exemplo, desde então nesse caso, eles produzam um arquivo cujo tamanho é maior que 1 GB) e retornar a média calculada e o número de casos para a rotina de chamada.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

Repetidamente, você está concatenando cadeias de caracteres grandes.You are repeatedly concatenating large strings.

Como cadeias de caracteres são imutáveis, cada operação de concatenação de cadeia de caracteres cria uma nova cadeia de caracteres.Because strings are immutable, each string concatenation operation creates a new string. O impacto para pequenas cadeias de caracteres, ou para um pequeno número de operações de concatenação é insignificante.The impact for small strings, or for a small number of concatenation operations, is negligible. Mas para grandes cadeias de caracteres ou um número muito grande de operações de concatenação, concatenação de cadeia de caracteres pode levar a um grande número de alocações de memória e a fragmentação de memória, baixo desempenho e possivelmente OutOfMemoryException exceções.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.

Quando a concatenação de cadeias de caracteres grandes ou executando um grande número de operações de concatenação, você deve usar o StringBuilder classe, em vez do String classe.When concatenating large strings or performing a large number of concatenation operations, you should use the StringBuilder class instead of the String class. Quando você tiver terminado de manipulação de cadeia de caracteres, converter o StringBuilder instância de uma cadeia de caracteres chamando o StringBuilder.ToString método.When you have finished manipulating the string, convert the StringBuilder instance to a string by calling the StringBuilder.ToString method.

Você pode fixar um grande número de objetos na memória.You pin a large number of objects in memory.

A fixação de um grande número de objetos na memória por longos períodos pode dificultar o coletor de lixo alocar blocos contíguos de memória.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. Se você fixou um grande número de objetos na memória, por exemplo, usando o fixed instrução em c# ou chamando o GCHandle.Alloc(Object, GCHandleType) método com um tipo de identificador de GCHandleType.Pinned, você pode fazer o seguinte endereço o OutOfMemoryException exceção.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.

  • Avalie se cada objeto realmente precisa ser fixado,Evaluate whether each object really needs to be pinned,

  • Certifique-se de que cada objeto é desafixado assim que possível.Ensure that each object is unpinned as soon as possible.

  • Certifique-se de que cada chamada para o GCHandle.Alloc(Object, GCHandleType) método para a memória de pin tem uma chamada correspondente para o GCHandle.Free método Desafixar que a memória.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.

A seguir Microsoft geram instruções de intermediário (MSIL) um OutOfMemoryException exceção:The following Microsoft intermediate (MSIL) instructions throw an OutOfMemoryException exception:

Construtores

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

Inicializa uma nova instância da classe OutOfMemoryException.Initializes a new instance of the OutOfMemoryException class.

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

Inicializa uma nova instância da classe OutOfMemoryException com dados serializados.Initializes a new instance of the OutOfMemoryException class with serialized data.

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

Inicializa uma nova instância da classe OutOfMemoryException com uma mensagem de erro especificada.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 uma nova instância da classe OutOfMemoryException com uma mensagem de erro especificada e uma referência à exceção interna que é a causa da exceção.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.

Propriedades

Data Data Data Data

Obtém uma coleção de pares de chave/valor que fornecem informações adicionais definidas pelo usuário sobre a exceção.Gets a collection of key/value pairs that provide additional user-defined information about the exception.

(Inherited from Exception)
HelpLink HelpLink HelpLink HelpLink

Obtém ou define um link para o arquivo de ajuda associado a essa exceção.Gets or sets a link to the help file associated with this exception.

(Inherited from Exception)
HResult HResult HResult HResult

Obtém ou define HRESULT, um valor numérico codificado que é atribuído a uma exceção específica.Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception.

(Inherited from Exception)
InnerException InnerException InnerException InnerException

Obtém a instância Exception que causou a exceção atual.Gets the Exception instance that caused the current exception.

(Inherited from Exception)
Message Message Message Message

Obtém uma mensagem que descreve a exceção atual.Gets a message that describes the current exception.

(Inherited from Exception)
Source Source Source Source

Obtém ou define o nome do aplicativo ou objeto que causa o erro.Gets or sets the name of the application or the object that causes the error.

(Inherited from Exception)
StackTrace StackTrace StackTrace StackTrace

Obtém uma representação de cadeia de caracteres de quadros imediatos na pilha de chamadas.Gets a string representation of the immediate frames on the call stack.

(Inherited from Exception)
TargetSite TargetSite TargetSite TargetSite

Obtém o método que gerou a exceção atual.Gets the method that throws the current exception.

(Inherited from Exception)

Métodos

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

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

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

Quando substituído em uma classe derivada, retorna a Exception que é a causa raiz de uma ou mais exceções subsequentes.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()

Serve como a função de hash padrão.Serves as the default hash function.

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

Quando substituído em uma classe derivada, define o SerializationInfo com informações sobre a exceção.When overridden in a derived class, sets the SerializationInfo with information about the exception.

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

Obtém o tipo de tempo de execução da instância atual.Gets the runtime type of the current instance.

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

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

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

Cria e retorna uma representação de cadeia de caracteres da exceção atual.Creates and returns a string representation of the current exception.

(Inherited from Exception)

Eventos

SerializeObjectState SerializeObjectState SerializeObjectState SerializeObjectState

Ocorre quando uma exceção é serializada para criar um objeto de estado de exceção que contém dados serializados sobre a exceção.Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception.

(Inherited from Exception)

Aplica-se a

Veja também