Logische boolesche Operatoren (C#-Referenz)Boolean logical operators (C# reference)

Die folgenden Operatoren führen logische Vorgänge mit bool-Operanden durch:The following operators perform logical operations with bool operands:

Für Operanden der integralen numerischen Typen führen die Operatoren &, | und ^ bitweise logische Operationen durch.For operands of the integral numeric types, the &, |, and ^ operators perform bitwise logical operations. Weitere Informationen finden Sie unter Bitweise und Schiebeoperatoren.For more information, see Bitwise and shift operators.

Logischer Negationsoperator: !Logical negation operator !

Der unäre Präfix-Operator ! berechnet die logische Negation seines Operanden.The unary prefix ! operator computes logical negation of its operand. Das heißt., er erzeugt true, wenn der Operand als false ausgewertet wird, und false, wenn der Operand als true ausgewertet wird: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

Ab C# 8.0 ist der unäre Postfix-Operator ! der NULL-tolerante Operator.Beginning with C# 8.0, the unary postfix ! operator is the null-forgiving operator.

Logischer AND-Operator &Logical AND operator &

Der &-Operator berechnet die logische AND-Operation des Operanden.The & operator computes the logical AND of its operands. Das Ergebnis von x & y ist true, wenn sowohl x als auch y zu true ausgewertet werden.The result of x & y is true if both x and y evaluate to true. Andernfalls ist das Ergebnis false.Otherwise, the result is false.

Der &-Operator wertet beide Operanden aus, selbst wenn der linke Operand als false ausgewertet wird, sodass das Ergebnis des Vorgangs unabhängig vom Wert des rechten Operanden false ist.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.

Im folgenden Beispiel ist der rechte Operand des &-Operators ein Methodenaufruf, der unabhängig vom Wert des linken Operanden ausgeführt wird: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

Der bedingte logische AND-Operator && berechnet auch die logische AND-Operation der Operanden, wertet den rechten Operanden aber nicht aus, wenn der linke Operand false ergibt.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.

Für Operanden der integralen numerischen Typen berechnet der Operator & bitweises logisches UND für seine Operanden.For operands of the integral numeric types, the & operator computes the bitwise logical AND of its operands. Der unäre &-Operator ist der address-of-Operator.The unary & operator is the address-of operator.

Logischer exklusiver OR-Operator: ^Logical exclusive OR operator ^

Die ^-Operator berechnet das logische exklusive OR, auch als logischer XOR bezeichnet, seiner Operanden.The ^ operator computes the logical exclusive OR, also known as the logical XOR, of its operands. Das Ergebnis von x ^ y ist true, wenn x true ergibt und y falseergibt, oder x false ergibt und y true ergibt.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. Andernfalls ist das Ergebnis false.Otherwise, the result is false. Das heißt, für die bool-Operanden berechnet der ^-Operator das gleiche Ergebnis wie der Ungleichheitsoperator !=.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

Für Operanden der integralen numerischen Typen berechnet der Operator ^ bitweises logisches exklusives ODER für seine Operanden.For operands of the integral numeric types, the ^ operator computes the bitwise logical exclusive OR of its operands.

Logischer OR-Operator: |Logical OR operator |

Der |-Operator berechnet die logische OR-Operation des Operanden.The | operator computes the logical OR of its operands. Das Ergebnis von x | y ist true, wenn entweder x oder y true ergibt.The result of x | y is true if either x or y evaluates to true. Andernfalls ist das Ergebnis false.Otherwise, the result is false.

Der |-Operator wertet beide Operanden aus, selbst wenn der linke Operand als true ausgewertet wird, sodass das Ergebnis des Vorgangs unabhängig vom Wert des rechten Operanden true ist.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.

Im folgenden Beispiel ist der rechte Operand des |-Operators ein Methodenaufruf, der unabhängig vom Wert des linken Operanden ausgeführt wird: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

Der bedingte logische OR-Operator || berechnet auch die logische OR-Operation der Operanden, wertet den rechten Operanden aber nicht aus, wenn der linke Operand true ergibt.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.

Für Operanden der integralen numerischen Typen berechnet der Operator | bitweises logisches ODER für seine Operanden.For operands of the integral numeric types, the | operator computes the bitwise logical OR of its operands.

Bedingter logischer AND-Operator &&Conditional logical AND operator &&

Der bedingte logische AND-Operator &&, auch bekannt als der "kurzschließender" logischer AND-Operator bezeichnet, berechnet die logische AND-Operation der Operanden.The conditional logical AND operator &&, also known as the "short-circuiting" logical AND operator, computes the logical AND of its operands. Das Ergebnis von x && y ist true, wenn sowohl x als auch y zu true ausgewertet werden.The result of x && y is true if both x and y evaluate to true. Andernfalls ist das Ergebnis false.Otherwise, the result is false. Wenn x als false ausgewertet wird, wird y nicht ausgewertet.If x evaluates to false, y is not evaluated.

Im folgenden Beispiel ist der rechte Operand des &&-Operators ein Methodenaufruf, der nicht ausgeführt wird, wenn der linke Operand false ergibt: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

Der logische AND-Operator & berechnet auch die logische AND-Operation der Operanden, es werden jedoch immer beide Operanden ausgewertet.The logical AND operator & also computes the logical AND of its operands, but always evaluates both operands.

Bedingter logischer OR-Operator ||Conditional logical OR operator ||

Der bedingte logische OR-Operator ||, auch bekannt als der "kurzschließender" logischer OR-Operator bezeichnet, berechnet die logische OR-Operation der Operanden.The conditional logical OR operator ||, also known as the "short-circuiting" logical OR operator, computes the logical OR of its operands. Das Ergebnis von x || y ist true, wenn entweder x oder y true ergibt.The result of x || y is true if either x or y evaluates to true. Andernfalls ist das Ergebnis false.Otherwise, the result is false. Wenn x als true ausgewertet wird, wird y nicht ausgewertet.If x evaluates to true, y is not evaluated.

Im folgenden Beispiel ist der rechte Operand des ||-Operators ein Methodenaufruf, der nicht ausgeführt wird, wenn der linke Operand true ergibt: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

Der logische OR-Operator | berechnet auch die logische OR-Operation der Operanden, es werden jedoch immer beide Operanden ausgewertet.The logical OR operator | also computes the logical OR of its operands, but always evaluates both operands.

Logische boolesche Operatoren, die NULL-Werte zulassenNullable Boolean logical operators

Für bool?-Operanden unterstützen die &- und |-Operatoren dreiwertige Logik.For bool? operands, the & and | operators support the three-valued logic. Die Semantik dieser Operatoren ist in der folgenden Tabelle definiert:The semantics of these operators is defined by the following table:

wx yy 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

Das Verhalten dieser Operatoren unterscheidet sich vom typischen Operatorverhalten bei Typen, die NULL-Werte zulassen.The behavior of those operators differs from the typical operator behavior with nullable value types. In der Regel kann ein Operator, der für Operanden eines Werttyps definiert ist, auch mit Operanden des entsprechenden Nullable-Typs verwendet werden.Typically, an operator which is defined for operands of a value type can be also used with operands of the corresponding nullable value type. Ein solcher Operator generiert null, wenn einer seiner Operanden in null ausgewertet wird.Such an operator produces null if any of its operands evaluates to null. Die &- und |-Operatoren können jedoch Nicht-NULL-Werte erzeugen, auch wenn einer der Operanden in null ausgewertet wird.However, the & and | operators can produce non-null even if one of the operands evaluates to null. Weitere Informationen zum Operatorverhalten bei Nullable-Werttypen finden Sie im Abschnitt „Lifted“ Operatoren des Artikels Nullable-Werttypen.For more information about the operator behavior with nullable value types, see the Lifted operators section of the Nullable value types article.

Sie können auch die !- und ^- Operatoren mit bool?-Operanden verwenden, wie das folgende Beispiel zeigt: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());

Die bedingten logischen Operatoren && und || unterstützen keine bool?-Operanden.The conditional logical operators && and || don't support bool? operands.

VerbundzuweisungCompound assignment

Bei einem binären Operator op entspricht ein Verbundzuweisungsausdruck der FormFor a binary operator op, a compound assignment expression of the form

x op= y

für die folgende Syntax:is equivalent to

x = x op y

außer dass x nur einmal überprüft wird.except that x is only evaluated once.

Die &-, |- und ^-Operatoren unterstützen die Verbundzuweisung, wie das folgende Beispiel zeigt: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

Die bedingten logischen Operatoren && und || unterstützen nicht die Verbundzuweisung.The conditional logical operators && and || don't support compound assignment.

OperatorrangfolgeOperator precedence

In der folgenden Liste sind die logischen Operatoren beginnend mit dem höchsten Rangfolgenoperator absteigend sortiert:The following list orders logical operators starting from the highest precedence to the lowest:

  • Logischer Negationsoperator !Logical negation operator !
  • Logischer AND-Operator &Logical AND operator &
  • Logischer exklusiver OR-Operator ^Logical exclusive OR operator ^
  • Logischer OR-Operator |Logical OR operator |
  • Bedingter logischer AND-Operator &&Conditional logical AND operator &&
  • Bedingter logischer OR-Operator ||Conditional logical OR operator ||

Verwenden Sie Klammern (), wenn Sie die Reihenfolge der Auswertung ändern möchten, die durch Operatorrangfolge festgelegt wird: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

Die vollständige Liste der nach Rangfolgenebene sortierten C#-Operatoren finden Sie im Abschnitt Operatorrangfolge im Artikel C#-Operatoren.For the complete list of C# operators ordered by precedence level, see the Operator precedence section of the C# operators article.

OperatorüberladbarkeitOperator overloadability

Ein benutzerdefinierter Typ kann die Operatoren !, &, | und ^ überladen.A user-defined type can overload the !, &, |, and ^ operators. Wenn ein binärer Operator überladen ist, wird der zugehörige Verbundzuweisungsoperator implizit auch überladen.When a binary operator is overloaded, the corresponding compound assignment operator is also implicitly overloaded. Ein benutzerdefinierter Typ kann einen Verbundzuweisungsoperator nicht explizit überladen.A user-defined type cannot explicitly overload a compound assignment operator.

Ein benutzerdefinierter Typ kann die bedingten logischen Operatoren && und || nicht überladen.A user-defined type cannot overload the conditional logical operators && and ||. Wenn jedoch ein benutzerdefinierter Typ die „true“ und „false“-Operatoren und den &- oder |-Operator in einer bestimmten Weise überlädt, kann die &&- bzw. ||-Operation für die Operanden dieses Typs ausgewertet werden.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. Weitere Informationen finden Sie im Abschnitt Benutzerdefinierte bedingte logische Operatoren der C#-Sprachspezifikation.For more information, see the User-defined conditional logical operators section of the C# language specification.

C#-SprachspezifikationC# language specification

Weitere Informationen finden Sie in den folgenden Abschnitten der C#-Sprachspezifikation:For more information, see the following sections of the C# language specification:

Siehe auchSee also