Opérateurs logiques booléens (référence C#)Boolean logical operators (C# reference)

Les opérateurs suivants effectuent des opérations logiques avec des opérandes bool :The following operators perform logical operations with bool operands:

Pour les opérandes des types numériques intégraux, les opérateurs &, |et ^ effectuent des opérations logiques au niveau du bit.For operands of the integral numeric types, the &, |, and ^ operators perform bitwise logical operations. Pour plus d’informations, consultez Opérateurs de bits et de décalage.For more information, see Bitwise and shift operators.

L’opérateur de négation logique !Logical negation operator !

L’opérateur de préfixe unaire ! calcule la négation logique de son opérande.The unary prefix ! operator computes logical negation of its operand. Autrement dit, il produit true si l’opérande donne false et false si l’opérande donne true :That is, it produces true, if the operand evaluates to false, and false, if the operand evaluates to true:

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

À partir C# de 8,0, l’opérateur unaire postfixé!est l' opérateur null-indulgent avec.Beginning with C# 8.0, the unary postfix ! operator is the null-forgiving operator.

Opérateur AND logique &Logical AND operator &

L’opérateur & calcule le AND logique de ses opérandes.The & operator computes the logical AND of its operands. Le résultat de x & y est true si x et y prennent la valeur true.The result of x & y is true if both x and y evaluate to true. Sinon, le résultat est false.Otherwise, the result is false.

L’opérateur & évalue les deux opérandes même si l’opérande de gauche a la valeur false, afin que le résultat de l’opération soit false quelle que soit la valeur de l’opérande de droite.The & operator evaluates both operands even if the left-hand operand evaluates to false, so that the operation result is false regardless of the value of the right-hand operand.

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 :In the following example, the right-hand operand of the & operator is a method call, which is performed regardless of the value of the left-hand operand:

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.The conditional logical AND operator && also computes the logical AND of its operands, but doesn't evaluate the right-hand operand if the left-hand operand evaluates to 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.For operands of the integral numeric types, the & operator computes the bitwise logical AND of its operands. L’opérateur unaire & est l’opérateur address-of.The unary & operator is the address-of operator.

L’opérateur OR exclusif logique ^Logical exclusive OR operator ^

L’opérateur ^ calcule le OR exclusif logique, également appelé XOR logique, de ses opérandes.The ^ operator computes the logical exclusive OR, also known as the logical XOR, of its operands. Le résultat de x ^ y est true si x donne true et y donne false, ou x donne false et y donne true.The result of x ^ y is true if x evaluates to true and y evaluates to false, or x evaluates to false and y evaluates to true. Sinon, le résultat est false.Otherwise, the result is false. Autrement dit, pour les opérandes bool, l’opérateur ^ calcule le même résultat que l’opérateur d’inégalité !=.That is, for the bool operands, the ^ operator computes the same result as the inequality operator !=.

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.For operands of the integral numeric types, the ^ operator computes the bitwise logical exclusive OR of its operands.

L’opérateur OU logique |Logical OR operator |

L’opérateur | calcule le OR logique de ses opérandes.The | operator computes the logical OR of its operands. Le résultat de x | y est true si x ou y prend la valeur true.The result of x | y is true if either x or y evaluates to true. Sinon, le résultat est false.Otherwise, the result is false.

L’opérateur | évalue les deux opérandes même si l’opérande de gauche a la valeur true, afin que le résultat de l’opération soit true quelle que soit la valeur de l’opérande de droite.The | operator evaluates both operands even if the left-hand operand evaluates to true, so that the operation result is true regardless of the value of the right-hand operand.

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 :In the following example, the right-hand operand of the | operator is a method call, which is performed regardless of the value of the left-hand operand:

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.The conditional logical OR operator || also computes the logical OR of its operands, but doesn't evaluate the right-hand operand if the left-hand operand evaluates to 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.For operands of the integral numeric types, the | operator computes the bitwise logical OR of its operands.

Opérateur AND logique conditionnel &&Conditional logical AND operator &&

L’opérateur AND logique conditionnel &&, également appelé opérateur AND logique de « court-circuit », calcule le AND logique de ses opérandes.The conditional logical AND operator &&, also known as the "short-circuiting" logical AND operator, computes the logical AND of its operands. Le résultat de x && y est true si x et y prennent la valeur true.The result of x && y is true if both x and y evaluate to true. Sinon, le résultat est false.Otherwise, the result is false. Si x donne la valeur de false, y n’est pas évalué.If x evaluates to false, y is not evaluated.

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 :In the following example, the right-hand operand of the && operator is a method call, which isn't performed if the left-hand operand evaluates to 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.The logical AND operator & also computes the logical AND of its operands, but always evaluates both operands.

L’opérateur OR logique conditionnel ||Conditional logical OR operator ||

L’opérateur OR logique conditionnel ||, également appelé opérateur OR logique de « court-circuit », calcule le OR logique de ses opérandes.The conditional logical OR operator ||, also known as the "short-circuiting" logical OR operator, computes the logical OR of its operands. Le résultat de x || y est true si x ou y prend la valeur true.The result of x || y is true if either x or y evaluates to true. Sinon, le résultat est false.Otherwise, the result is false. Si x donne la valeur de true, y n’est pas évalué.If x evaluates to true, y is not evaluated.

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 :In the following example, the right-hand operand of the || operator is a method call, which isn't performed if the left-hand operand evaluates to 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.The logical OR operator | also computes the logical OR of its operands, but always evaluates both operands.

Les opérateurs logiques booléens NullableNullable Boolean logical operators

Pour les opérandes bool?, les opérateurs & et | prennent en charge la logique à trois valeurs.For bool? operands, the & and | operators support the three-valued logic. La sémantique de ces opérateurs est définie par le tableau suivant :The semantics of these operators is defined by the following table:

xx oy x&yx&y x|yx|y
truetrue truetrue truetrue truetrue
truetrue falsefalse falsefalse truetrue
truetrue nullnull nullnull truetrue
falsefalse truetrue falsefalse truetrue
falsefalse falsefalse falsefalse falsefalse
falsefalse nullnull falsefalse nullnull
nullnull truetrue nullnull truetrue
nullnull falsefalse falsefalse nullnull
nullnull nullnull nullnull nullnull

Le comportement de ces opérateurs diffère du comportement classique des opérateurs avec des types valeur Nullable.The behavior of those operators differs from the typical operator behavior with nullable value types. 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.Typically, an operator which is defined for operands of a value type can be also used with operands of the corresponding nullable value type. Un tel opérateur produit null si l’un de ses opérandes a la valeur null.Such an operator produces null if any of its operands evaluates to null. Toutefois, les opérateurs & et | peuvent produire des valeurs non null, même si l’un des opérandes prend la valeur null.However, the & and | operators can produce non-null even if one of the operands evaluates to 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 .For more information about the operator behavior with nullable value types, see the Lifted operators section of the Nullable value types article.

Vous pouvez également utiliser les opérateurs ! et ^ avec des opérandes bool?, comme le montre l’exemple suivant :You can also use the ! and ^ operators with bool? operands, as the following example shows:

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?.The conditional logical operators && and || don't support bool? operands.

Assignation composéeCompound assignment

Pour un opérateur binaire op, une expression d’assignation composée du formulaireFor a binary operator op, a compound assignment expression of the form

x op= y

est équivalent àis equivalent to

x = x op y

sauf que x n’est évalué qu’une seule fois.except that x is only evaluated once.

Les opérateurs &, | et ^ prennent en charge l’assignation composée, comme le montre l’exemple suivant :The &, |, and ^ operators support compound assignment, as the following example shows:

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

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

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

Les opérateurs logiques conditionnels && et || ne prennent pas en charge l’assignation composée.The conditional logical operators && and || don't support compound assignment.

Priorité des opérateursOperator precedence

La liste suivante présente les opérateurs logiques par ordre de précédence, de la plus élevée à la plus basse :The following list orders logical operators starting from the highest precedence to the lowest:

  • Opérateur de négation logique !Logical negation operator !
  • L’opérateur AND logique &Logical AND operator &
  • Opérateur OR exclusif logique ^Logical exclusive OR operator ^
  • Opérateur OR logique |Logical OR operator |
  • Opérateur AND logique conditionnel &&Conditional logical AND operator &&
  • Opérateur OR logique conditionnel ||Conditional logical OR operator ||

Utilisez des parenthèses, (), pour modifier l’ordre d’évaluation imposé par la précédence des opérateurs :Use parentheses, (), to change the order of evaluation imposed by operator precedence:

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 C# des opérateurs classés par niveau de priorité, consultez la section priorité d' C# opérateur de l’article opérateurs.For the complete list of C# operators ordered by precedence level, see the Operator precedence section of the C# operators article.

Capacité de surcharge de l’opérateurOperator overloadability

Un type défini par l’utilisateur peut surcharger les opérateurs !, &, | et ^.A user-defined type can overload the !, &, |, and ^ operators. Quand un opérateur binaire est surchargé, l’opérateur d’assignation composée correspondant est aussi implicitement surchargé.When a binary operator is overloaded, the corresponding compound assignment operator is also implicitly overloaded. Un type défini par l’utilisateur ne peut pas surcharger explicitement un opérateur d’assignation composée.A user-defined type cannot explicitly overload a compound assignment operator.

Un type défini par l’utilisateur ne peut pas surcharger les opérateurs logiques conditionnels && et ||.A user-defined type cannot overload the conditional logical operators && and ||. 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.However, if a user-defined type overloads the true and false operators and the & or | operator in a certain way, the && or || operation, respectively, can be evaluated for the operands of that type. Pour plus d’informations, consultez la section Opérateurs logiques conditionnels définis par l’utilisateur de la spécification du langage C#.For more information, see the User-defined conditional logical operators section of the C# language specification.

spécification du langage C#C# language specification

Pour plus d’informations, consultez les sections suivantes de la spécification du langage C# :For more information, see the following sections of the C# language specification:

Voir aussiSee also