Opérateurs C#

Dans cet article, nous allons tout apprendre sur les différents types d'opérateurs en langage de programmation C# et comment les utiliser.

Les opérateurs sont des symboles utilisés pour effectuer des opérations sur les opérandes. Les opérandes peuvent être des variables et/ou des constantes.

Par exemple , en 2+3 , + est un opérateur qui est utilisé pour effectuer une opération d'addition, tandis que 2 et 3 sont des opérandes.

Les opérateurs sont utilisés pour manipuler des variables et des valeurs dans un programme. C# prend en charge un certain nombre d'opérateurs qui sont classés en fonction du type d'opérations qu'ils effectuent.

1. Opérateur d'affectation de base

L'opérateur d'affectation de base (=) est utilisé pour affecter des valeurs aux variables. Par exemple,

double x;
x = 50.05;

Ici, 50.05 est affecté à x.

Exemple 1 :Opérateur d'affectation de base

using System;

namespace Operator
{
	class AssignmentOperator
	{
		public static void Main(string[] args)
		{
			int firstNumber, secondNumber;
			// Assigning a constant to variable
			firstNumber = 10;
			Console.WriteLine("First Number = {0}", firstNumber);

			// Assigning a variable to another variable
			secondNumber = firstNumber;
			Console.WriteLine("Second Number = {0}", secondNumber);
		}
	}
}

Lorsque nous exécutons le programme, la sortie sera :

First Number = 10
Second Number = 10

Ceci est un exemple simple qui illustre l'utilisation de l'opérateur d'affectation.

Vous avez peut-être remarqué l'utilisation d'accolades { } dans l'exemple. Nous en discuterons dans le formatage des chaînes . Pour l'instant, gardez simplement à l'esprit que {0} est remplacé par la première variable qui suit la chaîne, {1} est remplacé par la deuxième variable et ainsi de suite.

2. Opérateurs arithmétiques

Les opérateurs arithmétiques sont utilisés pour effectuer des opérations arithmétiques telles que l'addition, la soustraction, la multiplication, la division, etc.

Par exemple,

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

Opérateurs arithmétiques C#
Opérateur	Nom de l'opérateur	Exemple
+	Opérateur d'addition	6 + 3 donne 9
-	Opérateur de soustraction	10 - 6 est évalué à 4
*	Opérateur de multiplication	4 * 2 donne 8
/	Opérateur de division	10 / 5 est évalué à 2
%	Opérateur modulo (reste)	16 % 3 est évalué à 1

Exemple 2 :Opérateurs arithmétiques

using System;
 
namespace Operator
{
	class ArithmeticOperator
	{
		public static void Main(string[] args)
		{
			double firstNumber = 14.40, secondNumber = 4.60, result;
			int num1 = 26, num2 = 4, rem;

			// Addition operator
			result = firstNumber + secondNumber;
			Console.WriteLine("{0} + {1} = {2}", firstNumber, secondNumber, result);

			// Subtraction operator
			result = firstNumber - secondNumber;
			Console.WriteLine("{0} - {1} = {2}", firstNumber, secondNumber, result);

			// Multiplication operator
			result = firstNumber * secondNumber;
			Console.WriteLine("{0} * {1} = {2}", firstNumber, secondNumber, result);

			// Division operator
			result = firstNumber / secondNumber;
			Console.WriteLine("{0} / {1} = {2}", firstNumber, secondNumber, result);

			// Modulo operator
			rem = num1 % num2;
			Console.WriteLine("{0} % {1} = {2}", num1, num2, rem);
		}
	}
}

Lorsque nous exécutons le programme, la sortie sera :

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

Des opérations arithmétiques sont effectuées dans l'exemple ci-dessus. Les variables peuvent être remplacées par des constantes dans les instructions. Par exemple,

result = 4.5 + 2.7 ; // result will hold 7.2
result = firstNumber - 3.2; // result will hold 11.2

3. Opérateurs relationnels

Les opérateurs relationnels sont utilisés pour vérifier la relation entre deux opérandes. Si la relation est vraie, le résultat sera true , sinon il en résultera false .

Les opérateurs relationnels sont utilisés dans la prise de décision et les boucles.

Opérateurs relationnels C#
Opérateur	Nom de l'opérateur	Exemple
==	Égal à	6 ==4 est évalué à faux
>	Supérieur à	3 > -1 est évalué comme vrai
<	Moins de	5 <3 est évalué à faux
>=	Supérieur ou égal à	4>=4 est évalué comme vrai
<=	Inférieur ou égal à	5 <=3 est évalué à faux
!=	Pas égal à	10 !=2 est évalué à vrai

Exemple 3 :Opérateurs relationnels

using System;
 
namespace Operator
{
	class RelationalOperator
	{
		public static void Main(string[] args)
		{
			bool result;
			int firstNumber = 10, secondNumber = 20;

			result = (firstNumber==secondNumber);
			Console.WriteLine("{0} == {1} returns {2}",firstNumber, secondNumber, result);

			result = (firstNumber > secondNumber);
			Console.WriteLine("{0} > {1} returns {2}",firstNumber, secondNumber, result);

			result = (firstNumber < secondNumber);
			Console.WriteLine("{0} < {1} returns {2}",firstNumber, secondNumber, result);

			result = (firstNumber >= secondNumber);
			Console.WriteLine("{0} >= {1} returns {2}",firstNumber, secondNumber, result);

			result = (firstNumber <= secondNumber);
			Console.WriteLine("{0} <= {1} returns {2}",firstNumber, secondNumber, result);

			result = (firstNumber != secondNumber);
			Console.WriteLine("{0} != {1} returns {2}",firstNumber, secondNumber, result);
		}
	}
}

Lorsque nous exécutons le programme, la sortie sera :

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

4. Opérateurs logiques

Les opérateurs logiques sont utilisés pour effectuer une opération logique telle que and , or . Les opérateurs logiques opèrent sur des expressions booléennes (true et false ) et renvoie des valeurs booléennes. Les opérateurs logiques sont utilisés dans la prise de décision et les boucles.

Voici comment le résultat est évalué pour le AND logique et OR opérateurs.

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

En termes simples, le tableau peut être résumé comme suit :

Si l'un des opérandes est vrai, le OR l'opérateur l'évaluera à true .
Si l'un des opérandes est faux, le AND l'opérateur l'évaluera à false .

Exemple 4 :Opérateurs logiques

using System;
 
namespace Operator
{
	class LogicalOperator
	{
		public static void Main(string[] args)
		{
			bool result;
			int firstNumber = 10, secondNumber = 20;

			// OR operator
			result = (firstNumber == secondNumber) || (firstNumber > 5);
			Console.WriteLine(result);

			// AND operator
			result = (firstNumber == secondNumber) && (firstNumber > 5);
			Console.WriteLine(result);
		}
	}
}

Lorsque nous exécutons le programme, la sortie sera :

True
False

5. Opérateurs unaires

Contrairement aux autres opérateurs, les opérateurs unaires opèrent sur un seul opérande.

Opérateurs unaires C#
Opérateur	Nom de l'opérateur	Description
+	Unaire Plus	Laisse le signe de l'opérande tel quel
-	Moins unaire	Inverse le signe de l'opérande
++	Incrément	Incrémenter la valeur de 1
--	Décrémenter	Décrémenter la valeur de 1
!	Négation logique (Non)	Inverse la valeur d'un booléen

Exemple 5 :Opérateurs unaires

using System;
 
namespace Operator
{
	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));
		}
	}
}

Lorsque nous exécutons le programme, la sortie sera :

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

L'incrément (++) et décrémenter (--) les opérateurs peuvent être utilisés comme préfixe et suffixe. S'il est utilisé comme préfixe, le changement de valeur de la variable est vu sur la même ligne et s'il est utilisé comme suffixe, le changement de valeur de la variable est vu sur la ligne suivante. Cela sera clair grâce à l'exemple ci-dessous.

Exemple 6 :Opérateurs Post et Pre Increment en C#

using System;
 
namespace Operator
{
	class UnaryOperator
	{
		public static void Main(string[] args)
		{
			int number = 10;

			Console.WriteLine((number++));
			Console.WriteLine((number));

			Console.WriteLine((++number));
			Console.WriteLine((number));
		}
	}
}

Lorsque nous exécutons le programme, la sortie sera :

Nous pouvons voir l'effet de l'utilisation de ++ comme préfixe et suffixe. Quand ++ est utilisé après l'opérande, la valeur est d'abord évaluée puis elle est incrémentée de 1 . D'où la déclaration

Console.WriteLine((number++));

imprime 10 au lieu de 11 . Une fois la valeur imprimée, la valeur du nombre est incrémentée de 1 .

Le processus est inverse lorsque ++ est utilisé comme préfixe. La valeur est incrémentée avant l'impression. D'où la déclaration

Console.WriteLine((++number));

imprime 12 .

Le cas est le même pour l'opérateur de décrémentation (--) .

6. Opérateur ternaire

L'opérateur ternaire ? : opère sur trois opérandes. C'est un raccourci pour if-then-else déclaration. L'opérateur ternaire peut être utilisé comme suit :

variable = Condition? Expression1 : Expression2;

L'opérateur ternaire fonctionne comme suit :

Si l'expression indiquée par Condition est true , le résultat de Expression1 est affecté à la variable.
Si c'est false , le résultat de Expression2 est affecté à la variable.

Exemple 7 :Opérateur ternaire

using System;
 
namespace Operator
{
	class TernaryOperator
	{
		public static void Main(string[] args)
		{
			int number = 10;
			string result;

			result = (number % 2 == 0)? "Even Number" : "Odd Number";
			Console.WriteLine("{0} is {1}", number, result);
		}
	}
}

Lorsque nous exécutons le programme, la sortie sera :

10 is Even Number

Pour en savoir plus, consultez Opérateur ternaire C# .

7. Opérateurs de bits et de décalage de bits

Les opérateurs de bit à bit et de décalage de bit sont utilisés pour effectuer des opérations de manipulation de bit.

Opérateurs C# Bitwise et Bit Shift
Opérateur	Nom de l'opérateur
~	Complément binaire
&	ET au niveau du bit
\|	OU au niveau du bit
^	OU exclusif au niveau du bit
<	Décalage bit à gauche
>>	Décalage au niveau du bit vers la droite

Exemple 8 :Opérateur de bit et de décalage de bit

using System;
 
namespace Operator
{
	class BitOperator
	{
		public static void Main(string[] args)
		{
			int firstNumber = 10;
			int secondNumber = 20;
			int 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);
		}
	}
}

Lorsque nous exécutons le programme, la sortie sera :

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

Pour en savoir plus, consultez Opérateur C# Bitwise et Bit Shift .

8. Opérateurs d'affectation composés

Opérateurs d'affectation composés C#
Opérateur	Nom de l'opérateur	Exemple	Équivalent à
+=	Affectation supplémentaire	`x += 5`	`x = x + 5`
-=	Affectation de soustraction	`x -= 5`	`x = x - 5`
*=	Affectation de multiplication	`x *= 5`	`x = x * 5`
/=	Affectation de division	`x /= 5`	`x = x / 5`
%=	Affectation modulo	`x %= 5`	`x = x % 5`
&=	Affectation AND au niveau du bit	`x &= 5`	`x = x & 5`
\|=	Affectation OR au niveau du bit	`x \|= 5`	`x = x \| 5`
^=	Affectation XOR au niveau du bit	`x ^= 5`	`x = x ^ 5`
<<=	Affectation du décalage à gauche	`x <<= 5`	`x = x << 5`
>>=	Affectation du décalage vers la droite	`x >>= 5`	`x = x >> 5`
=>	Opérateur Lambda	`x => x*x`	`Returns x*x`

Exemple 9 :Opérateur d'affectation composé

using System;
 
namespace Operator
{
	class BitOperator
	{
		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);
		}
	}
}

Lorsque nous exécutons le programme, la sortie sera :

Nous discuterons des opérateurs Lambda dans un tutoriel ultérieur.

Variables C# et types de données (primitifs) Priorité et associativité des opérateurs C#

Langue C