instruções marcadas e desmarcadas (referência em C#)

  • Artigo
  • 3 minutos para o fim da leitura

As checked instruções e unchecked especificam o contexto de verificação de estouro para operações aritméticas de tipo integral e conversões, como mostra o exemplo a seguir:

uint a = uint.MaxValue;

unchecked
{
    Console.WriteLine(a + 1);  // output: 0
}

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

Quando ocorre um estouro aritmético inteiro, o contexto de verificação de estouro define o que acontece da seguinte maneira:

  • Em um contexto verificado, um System.OverflowException é gerado; se o estouro ocorrer em uma expressão constante, ocorrerá um erro de tempo de compilação.
  • Em um contexto desmarcado, o resultado da operação é truncado descartando os bits de alta ordem que não se encaixam no tipo de destino. Por exemplo, no caso de adição, ele encapsula do valor máximo para o valor mínimo, como mostra o exemplo anterior.

Observação

O comportamento de operadores e conversões definidos pelo usuário no caso do estouro do tipo de resultado correspondente pode ser diferente do descrito no parágrafo anterior. Em particular, os operadores verificados definidos pelo usuário podem não gerar uma exceção em um contexto verificado.

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

Para especificar o contexto de verificação de estouro para uma expressão, você também pode usar o e unchecked os checked operadores, 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 checked instruções e unchecked os operadores afetam apenas o contexto de verificação de estouro para as operações que estão textualmente dentro dos parênteses do bloco de instrução ou do operador, como mostra o exemplo a seguir:

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 Multiply função local mostra que a checked instrução não afeta o contexto de verificação de estouro dentro da Multiply função, pois nenhuma exceção é gerada. 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 ela está textualmente dentro do bloco da checked instrução.

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

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

Contexto padrão de verificação de estouro

Se você não especificar o contexto de verificação de estouro, o valor da opção do compilador CheckForOverflowUnderflow definirá o contexto padrão para expressões não constantes. Por padrão, o valor dessa opção é não definido e as operações e conversões aritméticas de tipo integral são executadas em um contexto desmarcado .

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

Especificação da linguagem C#

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

Confira também