Opérateurs Logiques en C#

OperateursLogiques.md

Opérateurs Logiques en C#

En programmation, les opérateurs agissent sur deux opérandes et effectuent diverses opérations logiques ou arithmétiques.
Voici quelques-uns des opérateurs binaires les plus couramment utilisés en C#.

Opérateurs Logiques

ET Logique (&)

L'opérateur & effectue une opération logique ET bit à bit.

Exemple :

int a = 5;    // 0b0101
int b = 3;    // 0b0011
int result = a & b;  // 0b0001
Console.WriteLine(result);  // Affiche 1

OU Logique (|)

L'opérateur | effectue une opération logique OU bit à bit.

Exemple :

int a = 5;    // 0b0101
int b = 3;    // 0b0011
int result = a | b;  // 0b0111
Console.WriteLine(result);  // Affiche 7

OU Exclusif Logique (^)

L'opérateur ^ effectue une opération logique OU exclusif bit à bit.

Exemple :

int a = 5;    // 0b0101
int b = 3;    // 0b0011
int result = a ^ b;  // 0b0110
Console.WriteLine(result);  // Affiche 6

OU Logique Conditionnel (||)

L'opérateur || effectue une opération logique OU conditionnel. Il évalue le deuxième opérande uniquement si le premier est faux.

Exemple :

bool condition1 = true;
bool condition2 = false;
bool result = condition1 || condition2;  // Result est vrai, car condition1 est vraie
Console.WriteLine(result);  // Affiche True

ET Logique Conditionnel (&&)

L'opérateur && effectue une opération logique ET conditionnel. Il évalue le deuxième opérande uniquement si le premier est vrai.

Exemple :

bool condition1 = true;
bool condition2 = false;
bool result = condition1 && condition2;  // Result est faux, car condition2 est faux
Console.WriteLine(result);  // Affiche False

Opérateurs de Décalage

Décalage à Gauche (<<)

L'opérateur << effectue un décalage à gauche des bits.

Exemple :

int a = 5;    // 0b0101
int result = a << 2;  // 0b010100
Console.WriteLine(result);  // Affiche 20

Décalage à Droite (>>)

L'opérateur >> effectue un décalage à droite des bits avec extension de signe.

Exemple :

int a = -16;    // 0xFFFFFFF0
int result = a >> 2;  // 0xFFFFFFFC
Console.WriteLine(result);  // Affiche -4

Décalage à Droite Non Signé (>>>)

L'opérateur >>> est équivalent à l'opérateur >> en C# (>11), mais il ne conserver pas le signe. Cela signifie qu'il décale les bits vers la droite et remplit les bits de gauche avec des zéros, quel que soit le signe du nombre.

Exemple :

int a = -16;    // 0xFFFFFFF0 ou 11111111111111111111111111110000
int result = a >>> 2;    // 0x3FFFFFFC 00111111111111111111111111111100
Console.WriteLine(result);  // Affiche 1073741820

Conclusion

Les opérateurs binaires en C# sont des outils puissants pour effectuer des manipulations sur des données au niveau des bits. Ils sont largement utilisés dans des scénarios où la performance et la manipulation directe des bits sont cruciales, tels que le traitement des données binaires ou la gestion des drapeaux dans les énumérations.

Supposons que vous ayez une énumération drapeau représentant différents niveaux de journalisation dans une application. Vous pouvez utiliser l'opérateur | pour combiner plusieurs niveaux de journalisation :

[Flags]
enum LogLevel
{
    NONE = 0,
    INFO = 1,
    WARN = 2,
    ERROR = 4,
    DEBUG = 8
}

var logLevel = LogLevel.WARN | LogLevel.ERROR;  // Combinaison de niveaux de journalisation
Console.WriteLine(logLevel);  // Affiche 6 (2 | 4)

Dans cet exemple, LogLevel est une énumération drapeau (flag enum) où chaque valeur représente un niveau de journalisation.
En utilisant l'opérateur |, vous pouvez combiner plusieurs niveaux de journalisation. Cela peut être utile, par exemple, pour définir le niveau de journalisation minimal dans une application.