4. Expressions et opérateurs

Une expression est une séquence d'opérateurs et d'opérandes qui spécifient un traitement. C# dispose d'opérateurs unaires, d'opérateurs binaires et d'un opérateur ternaire.

4.1. Priorité des opérateurs

Lorsqu'une expression contient plusieurs opérateurs, la priorité des opérateurs contrôle l'ordre d'évaluation des opérateurs individuels. Lorsque les opérateurs ont la même priorité, leur associativité détermine l'ordre d'évaluation. Les opérateurs binaires (exceptés les opérateurs d'assignation) sont associatifs à gauche; c-à-d qu'ils sont évalués de la gauche vers la droite. Les opérateurs d'assignation, les opérateurs unaires et les opérateurs conditionnels sont associatifs à droite; c-à-d qu'ils sont évalués de la droite vers la gauche.
Code Résultat Remarques 
using System;

namespace Exemples
{
    class PrioriteOperateurs
    {
        static void Main(string[] args)
        {
            Console.WriteLine(1 + 2 + 3 * 4); // affiche 15;
            Console.ReadKey();
        }
    }
}
 
15
 
1 + 2 + 3 * 4
est évalué à : 
((1 + 2) + (3 * 4))
parce que * a une priorité plus haute que +, et que + est un opérateur binaire qui est associatif à gauche.
Le tableau suivant divise les opérateurs en catégories basées sur le type d'opération qu'ils exécutent. Les catégories sont répertoriées par ordre de priorité.
Catégorie Opérateurs
Primaire x.y, f(x), a[x], x++, x--, new, typeof, checked, unchecked
Unaire + - !, ~, ++x, --x, x (T)
Arithmétique - multiplication *, /, %
Arithmétique - addition +, -
Décalage <<, >>
Relationnel et test de type <, >, <=, >=, is, as
Égalité ==, !=
Logique, par ordre de priorité &, ^, |
Conditionnel, par ordre de priorité &&, ||, ?:
Assignation =, +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=

4.2. Vérifier le dépassement des opérateurs arithmétiques : checked

L'opérateur checked demande à l'environnement d'exécution de générer une OverflowException si une expression dépasse les limites arithmétiques d'un type.
Code Résultat Remarques 
using System;

namespace Exemples
{
    class DepassementOperateursArithmetiques
    {
        static void Main(string[] args)
        {
            int a = 1000000;
            int b = 1000000;
            int c;
            try
            {
                
                c = checked(a * b); // vérifie une expression
                Console.WriteLine(c); // affiche c
            }
            catch (OverflowException e)
            {
                Console.WriteLine(e.Message);
            }
            try
            {
                checked // vérifie chaque expression dans un bloc d'instructions
                {
                    c = a + b;
                    c = c * c;
                }
                Console.WriteLine(c); // affiche c
            }
            catch (OverflowException e)
            {
                Console.WriteLine(e.Message);
            }
            Console.ReadKey();
        }
    }
}
 
L'opération arithmétique a provoqué un dépassement de capacité.
L'opération arithmétique a provoqué un dépassement de capacité.
 Ici, on a provoqué deux dépassements dans une expression et dans un bloc...
L'opérateur checked ne s'applique qu'aux expressions évaluées par l'environnement d'exécution, puisque les expressions constantes sont vérifiées durant la compilation (Cependant, ceci peut être désactivé avec l'option /checked [+ | -] en ligne de commande). L'opérateur unchecked désactive la vérification arithmétique lors de la compilation et est rarement utile...

Pour plus d'information :
Opérateurs (Guide de programmation C#) : http://msdn.microsoft.com/fr-fr/library/ms173145%28v=vs.80%29.aspx