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 ^ 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 préfixé 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

À compter de C# 8,0, l’opérateur postfix unaire ! est l' opérateur null-indulgent avec.

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 est évalué à false , de sorte que le résultat de l’opération est 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 partie droite si l’opérande de partie gauche donne la valeur de false.

Pour les opérandes des types numériques intégraux, l' & opérateur calcule le 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 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

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 est évalué à true , de sorte que le résultat de l’opération est 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 le OR logique de ses opérandes, mais n’évalue pas l’opérande de partie droite si l’opérande de partie gauche donne la valeur de true.

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

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

  • L' & opérateur produit true uniquement si ses opérandes ont tous les deux la valeur true . Si ou a la x y valeur false , x & y produit false (même si un autre opérande a la valeur null ). Sinon, le résultat de x & y est null .

  • L' | opérateur produit false uniquement si ses opérandes ont tous les deux la valeur false . Si ou a la x y valeur true , x | y produit true (même si un autre opérande a la valeur null ). Sinon, le résultat de x | y est null .

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 a la valeur null . Toutefois, les & | opérateurs et peuvent produire des valeurs non null, même si l’un des opérandes a la valeur null . Pour plus d’informations sur le comportement de l’opérateur avec les types valeur Nullable, consultez la section opérateurs levés de l’article types valeur Nullable .

Vous pouvez également utiliser les ! ^ opérateurs et avec des bool? opérandes, 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 bool? 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# classés par niveau de priorité, consultez la section priorité d’opérateur 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# :

Voir aussi