Partilhar via

As instruções verificadas e não verificadas (referência C#)

As checked declarações e unchecked especificam o contexto de verificação de estouro para operações aritméticas de tipo integral e conversões. A instrução padrão é unchecked. Quando ocorre estouro aritmético inteiro, o contexto de verificação de estouro define o que acontece. Em um contexto verificado, um System.OverflowException é lançado; se ocorre um estouro em uma expressão constante, acontece um erro de tempo de compilação. Em um contexto não verificado, o resultado da operação é truncado ao descartar quaisquer bits de ordem alta que não cabem no tipo de destino. Por exemplo, a adição transita do valor máximo para o valor mínimo. O exemplo a seguir mostra a mesma operação em um contexto verificado e não verificado:

uint a = uint.MaxValue;

unchecked
{
    Console.WriteLine(a + 3);  // output: 2
}

try
{
    checked
    {
        Console.WriteLine(a + 3);
    }
}
catch (OverflowException e)
{
    Console.WriteLine(e.Message);  // output: Arithmetic operation resulted in an overflow.
}

Nota

O comportamento de estouro de operadores definidos pelo usuário e conversões pode diferir do descrito no parágrafo anterior. Em particular, os operadores verificados definidos pelo usuário podem não lançar uma exceção em um contexto verificado.

Para obter mais informações, consulte as seções Estouro aritmético e divisão por zero e operadores verificados definidos pelo usuário do artigo Operadores aritméticos.

Para especificar o contexto de verificação de estouro para uma expressão, pode também usar os operadores checked e unchecked, como mostra o exemplo a seguir:

double a = double.MaxValue;

int b = unchecked((int)a);
Console.WriteLine(b);  // output: -2147483648

try
{
    b = checked((int)a);
}
catch (OverflowException e)
{
    Console.WriteLine(e.Message);  // output: Arithmetic operation resulted in an overflow.
}

As instruções checked e operadores unchecked afetam apenas o contexto de verificação de estouro para as operações que estão textualmente dentro do bloco de instrução ou dos parênteses do operador, como o exemplo seguinte demonstra:

int Multiply(int a, int b) => a * b;

int factor = 2;

try
{
    checked
    {
        Console.WriteLine(Multiply(factor, int.MaxValue));  // output: -2
    }
}
catch (OverflowException e)
{
    Console.WriteLine(e.Message);
}

try
{
    checked
    {
        Console.WriteLine(Multiply(factor, factor * int.MaxValue));
    }
}
catch (OverflowException e)
{
    Console.WriteLine(e.Message);  // output: Arithmetic operation resulted in an overflow.
}

No exemplo anterior, a primeira invocação da função local Multiply mostra que a instrução checked não afeta o contexto de verificação de estouro dentro da função Multiply, visto que nenhuma exceção é lançada. Na segunda invocação da Multiply função, a expressão que calcula o segundo argumento da função é avaliada em um contexto verificado e resulta em uma exceção, pois está textualmente dentro do bloco da checked instrução.

O comportamento de checked e unchecked depende do tipo e da operação. Mesmo para números inteiros, operações como unchecked(x / 0) sempre lançam porque não há um comportamento sensato. Verifique o comportamento para o tipo e a operação para compreender como as palavras-chave checked e unchecked afetam o seu código.

Tipos numéricos e contexto de verificação de estouro

As palavras-chave checked e unchecked aplicam-se principalmente a tipos integrais onde há um comportamento de estouro adequado. O comportamento envolvente onde T.MaxValue + 1 se torna T.MinValue faz sentido em um valor de complemento de dois. O valor representado não está correto , pois não se enquadra no espaço de armazenamento do tipo. Portanto, os bits são representativos dos n-bits inferiores do resultado completo.

Para tipos como decimal, float, double, e Half que representam um valor mais complexo ou um valor de complemento, o wraparound não é sensato. Ele não pode ser usado para calcular resultados maiores ou mais precisos, por isso unchecked não é benéfico.

float, double e Half têm valores de saturação sensíveis para PositiveInfinity e NegativeInfinity, para que se possa detetar estouro num contexto unchecked. Para decimal não existem tais limites, e saturar em MaxValue pode levar a erros ou confusão. As operações que usam decimal lançam tanto em um contexto checked quanto em unchecked.

Operações influenciadas pelo contexto de verificação de estouro

O contexto de verificação de estouro afeta as seguintes operações:

  • Os seguintes operadores aritméticos integrados: operadores unários , ++, -- e operadores binários -, +, -, *, quando os operandos são de um tipo integral (isto é, tipo numérico integral ou tipo char) ou de um tipo enum.

  • Conversões numéricas explícitas entre tipos integrais ou de float ou double para um tipo integral.

    Nota

    Quando se converte um decimal valor para um tipo integral e o resultado está fora da gama do tipo de destino, uma OverflowException é sempre gerada, independentemente do contexto de verificação de estouro.

  • A partir do C# 11, operadores e conversões definidos pelo utilizador com verificação. Para obter mais informações, consulte a seção Operadores verificados definidos pelo usuário do artigo Operadores aritméticos.

Contexto padrão de verificação de transbordo

Se não especificar o contexto de verificação de estouro, o valor da opção do compilador CheckForOverflowUnderflow define o contexto padrão para expressões não constantes. Por padrão, o valor dessa opção é desdefinido e operações aritméticas de tipo integral e conversões são executadas em um contexto não verificado .

As expressões constantes são avaliadas por padrão em um contexto verificado e o estouro causa um erro em tempo de compilação. Você pode especificar explicitamente um contexto não verificado para uma expressão constante com a unchecked instrução ou operador.

Especificação da linguagem C#

Para obter mais informações, consulte as seguintes seções da especificação da linguagem C#:

Consulte também