Opérateurs C# — Guide complet des opérateurs en C#

Opérateurs C#

Explorez chaque catégorie d'opérateurs en C# et apprenez à les appliquer efficacement dans votre code.

Les opérateurs sont des symboles qui effectuent des actions sur un ou plusieurs opérandes — variables, constantes ou expressions. En C#, les opérateurs sont groupés par le type d'opération qu'ils exécutent, comme arithmétique, logique, bit à bit, et plus.

1. Opérateur d'affectation de base

L'opérateur d'affectation (=) stocke une valeur dans une variable.

double x; x = 50.05;

Exemple 1 : Utilisation de l'opérateur d'affectation

using System;
namespace OperatorDemo
{
    class AssignmentOperator
    {
        public static void Main(string[] args)
        {
            int firstNumber, secondNumber;
            firstNumber = 10;
            Console.WriteLine("Premier Nombre = {0}", firstNumber);
            secondNumber = firstNumber;
            Console.WriteLine("Second Nombre = {0}", secondNumber);
        }
    }
}

Sortie :

Premier Nombre = 10
Second Nombre = 10

2. Opérateurs arithmétiques

Les opérateurs arithmétiques effectuent des calculs mathématiques.

int x = 5; int y = 10; int z = x + y; // z = 15

Opérateurs arithmétiques C#
Opérateur	Nom	Exemple
+	Addition	6 + 3 = 9
-	Soustraction	10 - 6 = 4
*	Multiplication	4 * 2 = 8
/	Division	10 / 5 = 2
%	Modulo (reste)	16 % 3 = 1

Exemple 2 : Opérations arithmétiques

using System;
namespace OperatorDemo
{
    class ArithmeticOperator
    {
        public static void Main(string[] args)
        {
            double firstNumber = 14.40, secondNumber = 4.60, result;
            int num1 = 26, num2 = 4, rem;
            result = firstNumber + secondNumber;
            Console.WriteLine("{0} + {1} = {2}", firstNumber, secondNumber, result);
            result = firstNumber - secondNumber;
            Console.WriteLine("{0} - {1} = {2}", firstNumber, secondNumber, result);
            result = firstNumber * secondNumber;
            Console.WriteLine("{0} * {1} = {2}", firstNumber, secondNumber, result);
            result = firstNumber / secondNumber;
            Console.WriteLine("{0} / {1} = {2}", firstNumber, secondNumber, result);
            rem = num1 % num2;
            Console.WriteLine("{0} % {1} = {2}", num1, num2, rem);
        }
    }
}

Sortie :

14.4 + 4.6 = 19
14.4 - 4.6 = 9.8
14.4 * 4.6 = 66.24
14.4 / 4.6 = 3.1304347826087
26 % 4 = 2

3. Opérateurs relationnels

Ces opérateurs comparent deux opérandes et retournent un résultat booléen.

Opérateurs relationnels C#
Opérateur	Nom	Exemple
==	Égal à	6 == 4 → false
>	Supérieur à	3 > -1 → true
<	Inférieur à	5 < 3 → false
>=	Supérieur ou égal à	4 >= 4 → true
<=	Inférieur ou égal à	5 <= 3 → false
!=	Différent de	10 != 2 → true

Exemple 3 : Vérifications relationnelles

using System;
namespace OperatorDemo
{
    class RelationalOperator
    {
        public static void Main(string[] args)
        {
            bool result;
            int firstNumber = 10, secondNumber = 20;
            result = (firstNumber == secondNumber);
            Console.WriteLine("{0} == {1} retourne {2}", firstNumber, secondNumber, result);
            result = (firstNumber > secondNumber);
            Console.WriteLine("{0} > {1} retourne {2}", firstNumber, secondNumber, result);
            result = (firstNumber < secondNumber);
            Console.WriteLine("{0} < {1} retourne {2}", firstNumber, secondNumber, result);
            result = (firstNumber >= secondNumber);
            Console.WriteLine("{0} >= {1} retourne {2}", firstNumber, secondNumber, result);
            result = (firstNumber <= secondNumber);
            Console.WriteLine("{0} <= {1} retourne {2}", firstNumber, secondNumber, result);
            result = (firstNumber != secondNumber);
            Console.WriteLine("{0} != {1} retourne {2}", firstNumber, secondNumber, result);
        }
    }
}

Sortie :

10 == 20 retourne False
10 > 20 retourne False
10 < 20 retourne True
10 >= 20 retourne False
10 <= 20 retourne True
10 != 20 retourne True

4. Opérateurs logiques

Les opérateurs logiques évaluent des expressions booléennes.

Opérateurs logiques C#
Opérande 1	Opérande 2	OU (\|\|)	ET (&&)
true	true	true	true
true	false	true	false
false	true	true	false
false	false	false	false

Si l'un des opérandes est true, l'opérateur OU renvoie true.
Les deux opérandes doivent être true pour que ET retourne true.

Exemple 4 : Opérateurs logiques

using System;
namespace OperatorDemo
{
    class LogicalOperator
    {
        public static void Main(string[] args)
        {
            bool result;
            int firstNumber = 10, secondNumber = 20;
            result = (firstNumber == secondNumber) || (firstNumber > 5);
            Console.WriteLine(result);
            result = (firstNumber == secondNumber) && (firstNumber > 5);
            Console.WriteLine(result);
        }
    }
}

Sortie :

True
False

5. Opérateurs unaires

Les opérateurs unaires agissent sur un seul opérande.

Opérateurs unaires C#
Opérateur	Nom	Description
+	Plus unaire	Laisse le signe inchangé
-	Moins unaire	Nié le signe
++	Incrément	Augmente de 1
--	Décrément	Diminue de 1
!	NON logique	Inverse le booléen

Exemple 5 : Opérateurs unaires

using System;
namespace OperatorDemo
{
    class UnaryOperator
    {
        public static void Main(string[] args)
        {
            int number = 10, result;
            bool flag = true;
            result = +number;
            Console.WriteLine("+number = " + result);
            result = -number;
            Console.WriteLine("-number = " + result);
            result = ++number;
            Console.WriteLine("++number = " + result);
            result = --number;
            Console.WriteLine("--number = " + result);
            Console.WriteLine("!flag = " + (!flag));
        }
    }
}

Sortie :

+number = 10
-number = -10
++number = 11
--number = 10
!flag = False

Exemple 6 : Incrément préfixe vs postfixe

using System;
namespace OperatorDemo
{
    class UnaryOperator
    {
        public static void Main(string[] args)
        {
            int number = 10;
            Console.WriteLine(number++); // 10
            Console.WriteLine(number);   // 11
            Console.WriteLine(++number); // 12
            Console.WriteLine(number);   // 12
        }
    }
}

Sortie :

6. Opérateur ternaire

L'opérateur ternaire (? :) condense une instruction if-else en une seule ligne.

variable = Condition ? Expression1 : Expression2;

Si Condition est true, Expression1 est évaluée ; sinon Expression2 est utilisée.

Exemple 7 : Utilisation de l'opérateur ternaire

using System;
namespace OperatorDemo
{
    class TernaryOperator
    {
        public static void Main(string[] args)
        {
            int number = 10;
            string result = (number % 2 == 0) ? "Nombre Pair" : "Nombre Impair";
            Console.WriteLine("{0} est {1}", number, result);
        }
    }
}

Sortie :

10 est Nombre Pair

En apprendre plus sur l'opérateur ternaire C#.

7. Opérateurs bit à bit & décalage de bits

Ces opérateurs manipulent les bits individuels des types entiers.

Opérateurs bit à bit & décalage C#
Opérateur	Nom
~	Complément bit à bit
&	ET bit à bit
\|	OU bit à bit
^	OU exclusif (XOR)
<<	Décalage vers la gauche
>>	Décalage vers la droite

Exemple 8 : Opérations bit à bit

using System;
namespace OperatorDemo
{
    class BitOperator
    {
        public static void Main(string[] args)
        {
            int firstNumber = 10, secondNumber = 20, result;
            result = ~firstNumber;
            Console.WriteLine("~{0} = {1}", firstNumber, result);
            result = firstNumber & secondNumber;
            Console.WriteLine("{0} & {1} = {2}", firstNumber, secondNumber, result);
            result = firstNumber | secondNumber;
            Console.WriteLine("{0} | {1} = {2}", firstNumber, secondNumber, result);
            result = firstNumber ^ secondNumber;
            Console.WriteLine("{0} ^ {1} = {2}", firstNumber, secondNumber, result);
            result = firstNumber << 2;
            Console.WriteLine("{0} << 2 = {1}", firstNumber, result);
            result = firstNumber >> 2;
            Console.WriteLine("{0} >> 2 = {1}", firstNumber, result);
        }
    }
}

Sortie :

~10 = -11
10 & 20 = 0
10 | 20 = 30
10 ^ 20 = 30
10 << 2 = 40
10 >> 2 = 2

Pour plus de détails, visitez le guide des opérateurs bit à bit et décalage C#.

8. Opérateurs d'affectation composés

Ces opérateurs combinent une opération arithmétique avec l'affectation.

Opérateurs d'affectation composés C#
Opérateur	Nom	Exemple	Équivalent à
+=	Affectation addition	`x += 5`	`x = x + 5`
-=	Affectation soustraction	`x -= 5`	`x = x - 5`
*=	Affectation multiplication	`x *= 5`	`x = x * 5`
/=	Affectation division	`x /= 5`	`x = x / 5`
%=	Affectation modulo	`x %= 5`	`x = x % 5`
&=	Affectation ET bit à bit	`x &= 5`	`x = x & 5`
\|=	Affectation OU bit à bit	`x \|= 5`	`x = x \| 5`
^=	Affectation XOR bit à bit	`x ^= 5`	`x = x ^ 5`
<<=	Affectation décalage gauche	`x <<= 5`	`x = x << 5`
>>=	Affectation décalage droite	`x >>= 5`	`x = x >> 5`
=>	Opérateur lambda	`x => x * x`	Retourne x au carré

Exemple 9 : Utilisation des affectations composées

using System;
namespace OperatorDemo
{
    class CompoundOperator
    {
        public static void Main(string[] args)
        {
            int number = 10;
            number += 5;
            Console.WriteLine(number);
            number -= 3;
            Console.WriteLine(number);
            number *= 2;
            Console.WriteLine(number);
            number /= 3;
            Console.WriteLine(number);
            number %= 3;
            Console.WriteLine(number);
            number &= 10;
            Console.WriteLine(number);
            number |= 14;
            Console.WriteLine(number);
            number ^= 12;
            Console.WriteLine(number);
            number <<= 2;
            Console.WriteLine(number);
            number >>= 3;
            Console.WriteLine(number);
        }
    }
}

Sortie :

Les prochains tutoriels couvriront les expressions lambda en détail.

Maîtriser les variables C# et types de données primitifs : guide complet Maîtriser la priorité et l'associativité des opérateurs en C# : Guide pratique

Langue C