Opérateurs logiques booléens (référence C#)

Les opérateurs suivants effectuent des opérations logiques avec des opérandes bool :

Pour les opérandes des types numériques intégraux, les &|opérateurs et ^ les opérateurs effectuent des opérations logiques au niveau du bit. Pour plus d’informations, consultez Opérateurs de bits et de décalage.

L’opérateur de négation logique !

L’opérateur de préfixe ! unaire 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.

L’opérateur AND 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 les deux opérandes même si l’opérande de gauche prend la valeur false, de sorte que le résultat de l’opération soit false indépendamment de la valeur de l’opérande de droite.

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 prend la valeur false.

Pour les opérandes des types numériques intégraux, l’opérateur & calcule l’and logique au niveau du bit 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 bool opérandes, 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

Pour les opérandes des types numériques intégraux, l’opérateur ^ calcule l’or exclusif logique au niveau du bit 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 les deux opérandes même si l’opérande de gauche prend la valeur true, de sorte que le résultat de l’opération soit true indépendamment de la valeur de l’opérande de droite.

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 l’or logique de ses opérandes, mais n’évalue pas l’opérande de droite si l’opérande de gauche prend la valeur true.

Pour les opérandes des types numériques intégraux, l’opérateur | calcule l’or logique au niveau du bit de ses opérandes.

Opérateur AND 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 donne la valeur de 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 donne la valeur de 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 bool? les opérandes, les & opérateurs (AND logique) et | (OR logique) prennent en charge la logique à trois valeurs comme suit :

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

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

Le tableau suivant présente cette sémantique :

x y x&y x|y
true true true true
true false false true
true null null true
false true false true
false false false false
false null false null
null true null true
null false false null
null null null null

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 Nullable correspondant. Un tel opérateur produit null si l’un de ses opérandes est évalué à null. Toutefois, les & opérateurs peuvent | produire des valeurs non null même si l’un des opérandes est évalué à null. Pour plus d’informations sur le comportement de l’opérateur avec des types de valeurs nullables, consultez la section Opérateurs lifted de l’article types de valeurs Nullable .

Vous pouvez également utiliser les opérateurs avec ^bool? des opérandes, comme l’illustre 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 bool? les opérandes.

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

Notes

Les opérateurs logiques conditionnels && et || ne prennent pas en charge l’assignation composée.

Précédence 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# ordonnés par niveau de priorité, consultez la section Priorité desopérateurs C# .

Capacité de surcharge de l’opérateur

Un type défini par l’utilisateur peut surcharger les opérateurs, &|et ^ les !opérateurs. 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# :

Voir aussi