Utilisation vérifiée et non vérifiée de C#

Le mot-clé vérifié est utilisé pour activer explicitement la vérification de débordement pour les opérations arithmétiques et les conversions entières.

Par défaut, si une expression ne contient que des valeurs constantes, elle provoque une erreur du compilateur si la valeur résultante est en dehors de la plage du type cible. Si l'expression contient une ou plusieurs valeurs non constantes, le compilateur ne détecte pas de débordement. Dans l'exemple suivant, l'évaluation de l'expression affectée à i2 ne provoque pas d'erreur du compilateur.

// 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);

Par défaut, ces expressions non constantes ne sont pas vérifiées pour le débordement au moment de l'exécution, et ces expressions ne déclenchent pas d'exception de débordement. L'exemple ci-dessus montre -2 147 483 639 comme somme de deux entiers positifs.

La vérification de débordement peut être activée via les options du compilateur, la configuration de l'environnement ou en utilisant le mot-clé vérifié. L'exemple suivant montre comment utiliser une expression cochée ou un bloc coché pour détecter au moment de l'exécution un débordement provoqué par un calcul de somme précédent. Les deux exemples génèrent des exceptions de débordement.

// 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 vérification de débordement peut être annulée en utilisant décoché

Cet exemple montre comment utiliser vérifié pour activer la vérification de débordement d'exécution.

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
 */
}

Ce qui précède est le contenu de l'utilisation vérifiée et non vérifiée de C#. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !