OverflowException Classe

Definição

Namespace:

System

Assembly:

System.Runtime.dll

Origem:

OverflowException.cs

A exceção gerada quando uma operação aritmética, de conversão ou de conversão em um contexto verificado resulta em um estouro.

public ref class OverflowException : ArithmeticException

public class OverflowException : ArithmeticException

type OverflowException = class
    inherit ArithmeticException

Public Class OverflowException
Inherits ArithmeticException

Herança

Object

Exception

SystemException

ArithmeticException

OverflowException

Comentários

Um OverflowException é lançado em tempo de execução sob as seguintes condições:

• Uma operação aritmética produz um resultado que está fora do intervalo do tipo de dados retornado pela operação. O exemplo a seguir ilustra a OverflowException gerada por uma operação de multiplicação que estouram os limites do tipo Int32.

  int value = 780000000;
  checked {
  try {
     // Square the original value.
     int square = value * value;
     Console.WriteLine("{0} ^ 2 = {1}", value, square);
  }
  catch (OverflowException) {
     double square = Math.Pow(value, 2);
     Console.WriteLine("Exception: {0} > {1:E}.",
                       square, Int32.MaxValue);
  } }
  // The example displays the following output:
  //       Exception: 6.084E+17 > 2.147484E+009.
  

  open Checked
  
  let v = 780000000
  try
     // Square the original value.
     let square = v * v
     printfn $"{v} ^ 2 = {square}"
  with :? OverflowException ->
      let square = float v ** 2
      printfn $"Exception: {square} > {Int32.MaxValue:E}."
  // The example displays the following output:
  //       Exception: 6.084E+17 > 2.147484E+009.
  

  Dim value As Integer = 780000000
  Try
     ' Square the original value.
     Dim square As Integer = value * value 
     Console.WriteLine("{0} ^ 2 = {1}", value, square)
  Catch e As OverflowException
     Dim square As Double = Math.Pow(value, 2)
     Console.WriteLine("Exception: {0} > {1:E}.", _
                       square, Int32.MaxValue)
  End Try
  ' The example displays the following output:
  '       Exception: 6.084E+17 > 2.147484E+009.
  

• Uma operação de conversão ou conversão tenta executar uma conversão de restrição e o valor do tipo de dados de origem está fora do intervalo do tipo de dados de destino. O exemplo a seguir ilustra a OverflowException gerada pela tentativa de converter um grande valor de bytes sem sinal em um valor de byte assinado.

  byte value = 241;
  checked {
  try {
     sbyte newValue = (sbyte) value;
     Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
                       value.GetType().Name, value,
                       newValue.GetType().Name, newValue);
  }
  catch (OverflowException) {
     Console.WriteLine("Exception: {0} > {1}.", value, SByte.MaxValue);
  } }
  // The example displays the following output:
  //       Exception: 241 > 127.
  

  open Checked
  
  let value = 241uy
  try
      let newValue = int8 value
      printfn $"Converted the {value.GetType().Name} value {value} to the {newValue.GetType().Name} value {newValue}."
  with :? OverflowException ->
      printfn $"Exception: {value} > {SByte.MaxValue}."
  // The example displays the following output:
  //       Exception: 241 > 127.
  

  Dim value As Byte = 241
  Try
     Dim newValue As SByte = (CSByte(value))
     Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.", _
                       value.GetType().Name, value, _
                       newValue.GetType().Name, newValue)
  Catch e As OverflowException
     Console.WriteLine("Exception: {0} > {1}.", value, SByte.MaxValue)
  End Try                            
  ' The example displays the following output:
  '       Exception: 241 > 127.
  

Em cada caso, o resultado da operação é um valor menor que a propriedade MinValue ou maior que a propriedade MaxValue do tipo de dados resultante da operação.

Para que a operação aritmética, de conversão ou de conversão gere uma OverflowException, a operação deve ocorrer em um contexto verificado. Por padrão, as operações aritméticas e estouros no Visual Basic são verificados; em C# e F#, eles não são. Se a operação ocorrer em um contexto desmarcado, o resultado será truncado descartando os bits de alta ordem que não se encaixam no tipo de destino. O exemplo a seguir ilustra essa conversão desmarcada em C# ou F#. Ele repete o exemplo anterior em um contexto desmarcado.

byte value = 241;
try {
   sbyte newValue = (sbyte) value;
   Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
                     value.GetType().Name, value,
                     newValue.GetType().Name, newValue);
}
catch (OverflowException) {
   Console.WriteLine("Exception: {0} > {1}.", value, SByte.MaxValue);
}
// The example displays the following output:
//       Converted the Byte value 241 to the SByte value -15.

let value = 241uy
try
    let newValue = int8 value
    printfn $"Converted the {value.GetType().Name} value {value} to the {newValue.GetType().Name} value {newValue}."
with :? OverflowException ->
    printfn $"Exception: {value} > {SByte.MaxValue}."
// The example displays the following output:
//       Converted the Byte value 241 to the SByte value -15.

As seguintes instruções de MSIL (linguagem intermediária da Microsoft) lançam um OverflowException:

• add.ovf. <assinado>

• conv.ovf. <digitar>

• conv.ovf. <digitar>.un

• mul.ovf. <tipo>

• sub.ovf. <tipo>

• newarr

OverflowException usa o COR_E_OVERFLOW HRESULT, que tem o valor 0x80131516.

Para obter uma lista de valores de propriedade iniciais para uma instância de OverflowException, consulte os construtores de OverflowException.

Construtores

OverflowException()	Inicializa uma nova instância da classe OverflowException.
OverflowException(SerializationInfo, StreamingContext)	Obsoleto. Inicializa uma nova instância da classe OverflowException com dados serializados.
OverflowException(String)	Inicializa uma nova instância da classe OverflowException com uma mensagem de erro especificada.
OverflowException(String, Exception)	Inicializa uma nova instância da classe OverflowException com uma mensagem de erro especificada e uma referência à exceção interna que é a causa dessa exceção.

Propriedades

Data	Obtém uma coleção de pares chave/valor que fornecem informações adicionais definidas pelo usuário sobre a exceção. (Herdado de Exception)
HelpLink	Obtém ou define um link para o arquivo de ajuda associado a essa exceção. (Herdado de Exception)
HResult	Obtém ou define HRESULT, um valor numérico codificado atribuído a uma exceção específica. (Herdado de Exception)
InnerException	Obtém a instância de Exception que causou a exceção atual. (Herdado de Exception)
Message	Obtém uma mensagem que descreve a exceção atual. (Herdado de Exception)
Source	Obtém ou define o nome do aplicativo ou do objeto que causa o erro. (Herdado de Exception)
StackTrace	Obtém uma representação de cadeia de caracteres dos quadros imediatos na pilha de chamadas. (Herdado de Exception)
TargetSite	Obtém o método que gera a exceção atual. (Herdado de Exception)

Métodos

Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
GetBaseException()	Quando substituído em uma classe derivada, retorna o Exception que é a causa raiz de uma ou mais exceções subsequentes. (Herdado de Exception)
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetObjectData(SerializationInfo, StreamingContext)	Obsoleto. Quando substituído em uma classe derivada, define o SerializationInfo com informações sobre a exceção. (Herdado de Exception)
GetType()	Obtém o tipo de runtime da instância atual. (Herdado de Exception)
MemberwiseClone()	Cria uma cópia superficial do Objectatual. (Herdado de Object)
ToString()	Cria e retorna uma representação de cadeia de caracteres da exceção atual. (Herdado de Exception)

Eventos

SerializeObjectState

Obsoleto. Ocorre quando uma exceção é serializada para criar um objeto de estado de exceção que contém dados serializados sobre a exceção. (Herdado de Exception)

Confira também

• Exception
• de tratamento e geração de exceções