Opérateurs logiques booléens - AND, OR, NOT, XOR

Les opérateurs booléens logiques effectuent des opérations logiques avec des opérandes bool. Les opérateurs incluent la négation logique unaire (!), la logique binaire AND (&), OR (|) et OR exclusif (^) et la logique binaire AND (&&) et OR (||).

• opérateur unaire ! (négation logique) ;
• opérateurs binaires & (AND logique), | (OR logique) et ^ (OR exclusif logique), qui évaluent toujours les deux opérandes ;
• opérateurs binaires && (AND logique conditionnel) et || (OR logique conditionnel), Ces opérateurs n’évaluent l’opérande de partie droite que si nécessaire.

En ce qui concerne les opérandes de type numérique intégral, les opérateurs &, | et ^ effectuent des opérations logiques binaires. Pour plus d’informations, consultez Opérateurs de bits et de décalage.

L’opérateur de négation logique !

L’opérateur unaire préfixe ! calcule la négation logique de son opérande. Autrement dit, il produit true si l’opérande donne false et false si l’opérande donne true :

bool passed = false;
Console.WriteLine(!passed);  // output: True
Console.WriteLine(!true);    // output: False

L’opérateur postfix ! unaire est l’opérateur null-forgiving.

Opérateur ET logique &

L’opérateur & calcule le AND logique de ses opérandes. Le résultat de x & y est true si x et y prennent la valeur true. Sinon, le résultat est false.

L’opérateur & évalue toujours les deux opérandes. Lorsque l’opérande de gauche est évalué à false, le résultat de l’opération est false, quelle que soit la valeur de l’opérande de droite. Même ensuite, l’opérande de droite est toutefois évalué.

Dans l’exemple suivant, l’opérande de partie droite de l’opérateur & est un appel de méthode, effectué indépendamment de la valeur de l’opérande de partie gauche :

bool SecondOperand()
{
    Console.WriteLine("Second operand is evaluated.");
    return true;
}

bool a = false & SecondOperand();
Console.WriteLine(a);
// Output:
// Second operand is evaluated.
// False

bool b = true & SecondOperand();
Console.WriteLine(b);
// Output:
// Second operand is evaluated.
// True

L’opérateur AND logique conditionnel && calcule également le AND logique de ses opérandes, mais n’évalue pas l’opérande de droite si l’opérande de gauche s’évalue à false.

Dans le cas des opérandes de types numériques intégraux, &l’opérateur calcule le AND logique binaire de ses opérandes. L’opérateur unaire & est l’opérateur address-of.

L’opérateur OR exclusif logique ^

L’opérateur ^ calcule le OR exclusif logique, également appelé XOR logique, de ses opérandes. Le résultat de x ^ y est true si x donne true et y donne false, ou x donne false et y donne true. Sinon, le résultat est false. Autrement dit, pour les opérandes bool, l’opérateur ^ calcule le même résultat que l’opérateur d’inégalité !=.

Console.WriteLine(true ^ true);    // output: False
Console.WriteLine(true ^ false);   // output: True
Console.WriteLine(false ^ true);   // output: True
Console.WriteLine(false ^ false);  // output: False

Dans le cas des opérandes de types numériques intégraux, ^l’opérateur calcule l’opération logique exclusive OU binaire de ses opérandes.

L’opérateur OU logique |

L’opérateur | calcule le OR logique de ses opérandes. Le résultat de x | y est true si x ou y prend la valeur true. Sinon, le résultat est false.

L’opérateur | évalue toujours les deux opérandes. Lorsque l’opérande de gauche est évalué à true, le résultat de l’opération est true, quelle que soit la valeur de l’opérande de droite. Même ensuite, l’opérande de droite est toutefois évalué.

Dans l’exemple suivant, l’opérande de partie droite de l’opérateur | est un appel de méthode, effectué indépendamment de la valeur de l’opérande de partie gauche :

bool SecondOperand()
{
    Console.WriteLine("Second operand is evaluated.");
    return true;
}

bool a = true | SecondOperand();
Console.WriteLine(a);
// Output:
// Second operand is evaluated.
// True

bool b = false | SecondOperand();
Console.WriteLine(b);
// Output:
// Second operand is evaluated.
// True

L’opérateur OR logique conditionnel || calcule également le OR logique de ses opérandes, mais n’évalue pas l’opérande de droite si l’opérande de gauche s’évalue à true.

Dans le cas des opérandes de types numériques intégraux, |l’opérateur calcule le OR logique binaire de ses opérandes.

Opérateur ET logique conditionnel &&

L’opérateur AND logique conditionnel &&, également appelé opérateur AND logique de « court-circuit », calcule le AND logique de ses opérandes. Le résultat de x && y est true si x et y prennent la valeur true. Sinon, le résultat est false. Si x est évalué à false, y n’est pas évalué.

Dans l’exemple suivant, l’opérande de partie droite de l’opérateur && est un appel de méthode, non effectué si l’opérande de partie gauche donne la valeur de false :

bool SecondOperand()
{
    Console.WriteLine("Second operand is evaluated.");
    return true;
}

bool a = false && SecondOperand();
Console.WriteLine(a);
// Output:
// False

bool b = true && SecondOperand();
Console.WriteLine(b);
// Output:
// Second operand is evaluated.
// True

L’opérateur AND logique & calcule également le AND logique de ses opérandes, mais évalue toujours les deux opérandes.

L’opérateur OR logique conditionnel ||

L’opérateur OR logique conditionnel ||, également appelé opérateur OR logique de « court-circuit », calcule le OR logique de ses opérandes. Le résultat de x || y est true si x ou y prend la valeur true. Sinon, le résultat est false. Si x est évalué à true, y n’est pas évalué.

Dans l’exemple suivant, l’opérande de partie droite de l’opérateur || est un appel de méthode, non effectué si l’opérande de partie gauche donne la valeur de true :

bool SecondOperand()
{
    Console.WriteLine("Second operand is evaluated.");
    return true;
}

bool a = true || SecondOperand();
Console.WriteLine(a);
// Output:
// True

bool b = false || SecondOperand();
Console.WriteLine(b);
// Output:
// Second operand is evaluated.
// True

L’opérateur OR logique | calcule également le OR logique de ses opérandes, mais évalue toujours les deux opérandes.

Les opérateurs logiques booléens Nullable

Pour les opérandes bool?, les opérateurs &(AND logique) et | (OR logique) prennent en charge la logique à trois valeurs comme suit :

• L’opérateur & produit true uniquement si les deux opérandes sont évalués à true. Si l’une ou l’autre de x ou y est évaluée à false, x & y produit false (même si un autre opérande est évalué à null ). Sinon, le résultat de x & y est null.

• L’opérateur | produit false uniquement si les deux opérandes sont évalués à false. Si l’une ou l’autre de x ou y est évaluée à true, x | y produit true (même si un autre opérande est évalué à null ). Sinon, le résultat de x | y est null.

Le tableau suivant présente cette sémantique :

Le comportement de ces opérateurs diffère du comportement classique des opérateurs avec des types valeur Nullable. En règle générale, un opérateur défini pour les opérandes d’un type valeur peut être également utilisé avec des opérandes du type valeur pouvant accepter la valeur Null correspondante. Un tel opérateur produit null si l’un de ses opérandes est null. Toutefois, les opérateurs & et | peuvent produire une valeur non null même si l’un des opérandes est évalué à null. Pour plus d’informations sur le comportement des opérateurs avec des types valeur pouvant accepter la valeur Null, voir la section Opérateurs de l’article Utiliser des types pouvant accepter la valeur Null.

Vous pouvez également utiliser les opérateurs ! et ^ avec les opérandes bool?, comme le montre l’exemple suivant :

bool? test = null;
Display(!test);         // output: null
Display(test ^ false);  // output: null
Display(test ^ null);   // output: null
Display(true ^ null);   // output: null

void Display(bool? b) => Console.WriteLine(b is null ? "null" : b.Value.ToString());

Les opérateurs logiques conditionnels && et || ne prennent pas en charge les opérandes bool?.

Assignation composée

Pour un opérateur binaire op, une expression d’assignation composée du formulaire

x op= y

équivaut à :

x = x op y

sauf que x n’est évalué qu’une seule fois.

Les opérateurs &, | et ^ prennent en charge l’assignation composée, comme le montre l’exemple suivant :

bool test = true;
test &= false;
Console.WriteLine(test);  // output: False

test |= true;
Console.WriteLine(test);  // output: True

test ^= false;
Console.WriteLine(test);  // output: True

Priorité des opérateurs

La liste suivante présente les opérateurs logiques par ordre de précédence, de la plus élevée à la plus basse :

• Opérateur de négation logique !
• L’opérateur AND logique &
• Opérateur OR exclusif logique ^
• Opérateur OR logique |
• Opérateur AND logique conditionnel &&
• Opérateur OR logique conditionnel ||

Utilisez des parenthèses, (), pour modifier l’ordre d’évaluation imposé par la précédence des opérateurs :

Console.WriteLine(true | true & false);   // output: True
Console.WriteLine((true | true) & false); // output: False

bool Operand(string name, bool value)
{
    Console.WriteLine($"Operand {name} is evaluated.");
    return value;
}

var byDefaultPrecedence = Operand("A", true) || Operand("B", true) && Operand("C", false);
Console.WriteLine(byDefaultPrecedence);
// Output:
// Operand A is evaluated.
// True

var changedOrder = (Operand("A", true) || Operand("B", true)) && Operand("C", false);
Console.WriteLine(changedOrder);
// Output:
// Operand A is evaluated.
// Operand C is evaluated.
// False

Pour obtenir la liste complète des opérateurs C# classés par niveau de priorité, consultez la section Priorité des opérateurs de l’article Opérateurs C#.

Capacité de surcharge de l’opérateur

Un type défini par l’utilisateur peut surcharger les opérateurs !, &, | et ^. Quand un opérateur binaire est surchargé, l’opérateur d’assignation composée correspondant est aussi implicitement surchargé. Un type défini par l’utilisateur ne peut pas surcharger explicitement un opérateur d’assignation composée.

Un type défini par l’utilisateur ne peut pas surcharger les opérateurs logiques conditionnels && et ||. Toutefois, si un type défini par l’utilisateur surcharge les opérateurs true et false et l’opérateur & ou | d’une certaine manière, l’opération && ou || peut être évaluée respectivement pour les opérandes de ce type. Pour plus d’informations, consultez la section Opérateurs logiques conditionnels définis par l’utilisateur de la spécification du langage C#.

spécification du langage C#

Pour plus d’informations, consultez les sections suivantes de la spécification du langage C# :

• Opérateur de négation logique
• Opérateurs logiques
• Opérateurs logiques conditionnels
• Assignation composée

Voir aussi

• Opérateurs et expressions C#
• Opérateurs de bits et de décalage