checked (Riferimenti per C#)checked (C# Reference)

La parola chiave checked viene usata per abilitare in modo esplicito il controllo dell'overflow per le conversioni e le operazioni aritmetiche di tipo integrale.The checked keyword is used to explicitly enable overflow checking for integral-type arithmetic operations and conversions.

Per impostazione predefinita, un'espressione che contiene solo valori costanti provoca un errore di compilazione se l'espressione produce un valore che non è incluso nell'intervallo del tipo di destinazione.By default, an expression that contains only constant values causes a compiler error if the expression produces a value that is outside the range of the destination type. Se l'espressione contiene uno o più valori non costanti, il compilatore non rileva l'overflow.If the expression contains one or more non-constant values, the compiler does not detect the overflow. La valutazione dell'espressione assegnata a i2 nell'esempio seguente non genera un errore di compilazione.Evaluating the expression assigned to i2 in the following example does not cause a compiler error.

// The following example causes compiler error CS0220 because 2147483647
// is the maximum value for integers.
//int i1 = 2147483647 + 10;

// The following example, which includes variable ten, does not cause
// a compiler error.
int ten = 10;
int i2 = 2147483647 + ten;

// By default, the overflow in the previous statement also does
// not cause a run-time exception. The following line displays
// -2,147,483,639 as the sum of 2,147,483,647 and 10.
Console.WriteLine(i2);

Per impostazione predefinita, in queste espressioni non costanti non viene verificato l'overflow in fase di esecuzione e non vengono generate eccezioni di overflow.By default, these non-constant expressions are not checked for overflow at run time either, and they do not raise overflow exceptions. Nell'esempio precedente viene visualizzato il valore -2,147,483,639 come somma di due numeri interi positivi.The previous example displays -2,147,483,639 as the sum of two positive integers.

Il controllo dell'overflow può essere abilitato tramite le opzioni del compilatore, la configurazione dell'ambiente o l'uso della parola chiave checked.Overflow checking can be enabled by compiler options, environment configuration, or use of the checked keyword. Gli esempi seguenti illustrano come usare un'espressione checked o un blocco checked per rilevare l'overflow generato dalla somma precedente in fase di esecuzione.The following examples demonstrate how to use a checked expression or a checked block to detect the overflow that is produced by the previous sum at run time. Entrambi gli esempi generano un'eccezione di overflow.Both examples raise an overflow exception.

// If the previous sum is attempted in a checked environment, an
// OverflowException error is raised.

// Checked expression.
Console.WriteLine(checked(2147483647 + ten));

// Checked block.
checked
{
    int i3 = 2147483647 + ten;
    Console.WriteLine(i3);
}

La parola chiave unchecked può essere usata per impedire il controllo dell'overflow.The unchecked keyword can be used to prevent overflow checking.

EsempioExample

Questo esempio illustra come usare checked per abilitare il controllo dell'overflow in fase di esecuzione.This sample shows how to use checked to enable overflow checking at run time.

class OverFlowTest
{
    // Set maxIntValue to the maximum value for integers.
    static int maxIntValue = 2147483647;

    // Using a checked expression.
    static int CheckedMethod()
    {
        int z = 0;
        try
        {
            // The following line raises an exception because it is checked.
            z = checked(maxIntValue + 10);
        }
        catch (System.OverflowException e)
        {
            // The following line displays information about the error.
            Console.WriteLine("CHECKED and CAUGHT:  " + e.ToString());
        }
        // The value of z is still 0.
        return z;
    }

    // Using an unchecked expression.
    static int UncheckedMethod()
    {
        int z = 0;
        try
        {
            // The following calculation is unchecked and will not
            // raise an exception.
            z = maxIntValue + 10;
        }
        catch (System.OverflowException e)
        {
            // The following line will not be executed.
            Console.WriteLine("UNCHECKED and CAUGHT:  " + e.ToString());
        }
        // Because of the undetected overflow, the sum of 2147483647 + 10 is
        // returned as -2147483639.
        return z;
    }

    static void Main()
    {
        Console.WriteLine("\nCHECKED output value is: {0}",
                          CheckedMethod());
        Console.WriteLine("UNCHECKED output value is: {0}",
                          UncheckedMethod());
    }
    /*
   Output:
   CHECKED and CAUGHT:  System.OverflowException: Arithmetic operation resulted
   in an overflow.
      at ConsoleApplication1.OverFlowTest.CheckedMethod()

   CHECKED output value is: 0
   UNCHECKED output value is: -2147483639
 */
}

Specifiche del linguaggio C#C# language specification

Per ulteriori informazioni, vedere la specifica del linguaggio C#.For more information, see the C# Language Specification. La specifica del linguaggio costituisce il riferimento ufficiale principale per la sintassi e l'uso di C#.The language specification is the definitive source for C# syntax and usage.

Vedere ancheSee also