Boolesche logische Operatoren: AND, OR, NOT, XOR

Die booleschen logische Operatoren führen logische Vorgänge mit bool-Operanden durch. Die Operatoren umfassen die unäre logische Negation (!), binäres logisches AND (&), OR (|) und exklusives OR (^) sowie binäres bedingtes logisches AND (&&) und OR (||).

• Unärer ! (logische Negation) Operator.
• Binäre & (logisch AND), | (logisch OR) und ^ (logisch exklusiv OR) Operatoren. Diese Operatoren werten immer beide Operanden aus.
• Binäre && (bedingt logisch AND) und || (bedingt logisch OR) Operatoren. Diese Operatoren werten den rechten Operanden nur dann aus, wenn es notwendig ist.

Für Operanden der integralen numerischen Typen führen die Operatoren &, | und ^ bitweise logische Operationen durch. Weitere Informationen finden Sie unter Bitweise und Schiebeoperatoren.

Logischer Negationsoperator: !

Der unäre Präfix-Operator ! berechnet die logische Negation seines Operanden. Das heißt., er erzeugt true, wenn der Operand als false ausgewertet wird, und false, wenn der Operand als true ausgewertet wird:

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

Der unäre Postfix-Operator ! ist der NULL-tolerante Operator.

Logischer AND-Operator &

Der &-Operator berechnet die logische AND-Operation des Operanden. Das Ergebnis von x & y ist true, wenn sowohl x als auch y zu true ausgewertet werden. Andernfalls ist das Ergebnis false.

Der &-Operator wertet immer beide Operanden aus. Wenn der linke Operand als false ausgewertet wird, ist das Ergebnis des Vorgangs unabhängig vom Wert des rechten Operanden false. Aber auch dann wird der rechte Operand ausgewertet.

Im folgenden Beispiel ist der rechte Operand des &-Operators ein Methodenaufruf, der unabhängig vom Wert des linken Operanden ausgeführt wird:

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.

Für Operanden der integralen numerischen Typen berechnet der Operator &bitweises logisches UND für seine Operanden. Der unäre &-Operator ist der address-of-Operator.

Logischer exklusiver OR-Operator: ^

Die ^-Operator berechnet das logische exklusive OR, auch als logischer XOR bezeichnet, seiner Operanden. Das Ergebnis von x ^ y ist true, wenn xtrue ergibt und yfalseergibt, oder xfalse ergibt und ytrue ergibt. Andernfalls ist das Ergebnis false. Das heißt, für die bool-Operanden berechnet der ^-Operator das gleiche Ergebnis wie der Ungleichheitsoperator!=.

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.

Logischer OR-Operator: |

Der |-Operator berechnet die logische OR-Operation des Operanden. Das Ergebnis von x | y ist true, wenn entweder x oder ytrue ergibt. Andernfalls ist das Ergebnis false.

Der |-Operator wertet immer beide Operanden aus. Wenn der linke Operand als true ausgewertet wird, ist das Ergebnis des Vorgangs unabhängig vom Wert des rechten Operanden true. Aber auch dann wird der rechte Operand ausgewertet.

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

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.

Für Operanden der integralen numerischen Typen berechnet der Operator |bitweises logisches ODER für seine Operanden.

Bedingter logischer AND-Operator &&

Der bedingte logische AND-Operator &&, auch bekannt als der "kurzschließender" logischer AND-Operator bezeichnet, berechnet die logische AND-Operation der Operanden. Das Ergebnis von x && y ist true, wenn sowohl x als auch y zu true ausgewertet werden. Andernfalls ist das Ergebnis false. Wenn x als false ausgewertet wird, wird y nicht ausgewertet.

Im folgenden Beispiel ist der rechte Operand des &&-Operators ein Methodenaufruf, der nicht ausgeführt wird, wenn der linke Operand false ergibt:

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.

Bedingter logischer OR-Operator ||

Der bedingte logische OR-Operator ||, auch bekannt als der "kurzschließender" logischer OR-Operator bezeichnet, berechnet die logische OR-Operation der Operanden. Das Ergebnis von x || y ist true, wenn entweder x oder ytrue ergibt. Andernfalls ist das Ergebnis false. Wenn x als true ausgewertet wird, wird y nicht ausgewertet.

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

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.

Logische boolesche Operatoren, die NULL-Werte zulassen

Für bool?-Operanden unterstützen die Operatoren & (logisches UND) und | (logisches ODER) die dreiwertige Logik wie folgt:

• Für den Operator & wird nur true zurückgegeben, wenn auch beide seiner Operanden true ergeben. Wenn für x und yfalse zurückgegeben wird, ergibt x & yfalse (auch wenn ein anderer Operand null ergibt). Andernfalls ist das Ergebnis von x & ynull.

• Für den Operator | wird nur false zurückgegeben, wenn auch beide seiner Operanden false ergeben. Wenn für x und ytrue zurückgegeben wird, ergibt x | ytrue (auch wenn ein anderer Operand null ergibt). Andernfalls ist das Ergebnis von x | ynull.

Der folgenden Tabelle können Sie die Semantik entnehmen:

w	Y	x & y	x | y
Wahr	Wahr	Wahr	Wahr
Wahr	Falsch	Falsch	Wahr
Wahr	NULL	NULL	Wahr
Falsch	Wahr	Falsch	Wahr
Falsch	Falsch	Falsch	Falsch
Falsch	NULL	Falsch	NULL
NULL	Wahr	NULL	Wahr
NULL	Falsch	Falsch	NULL
NULL	NULL	NULL	NULL

Das Verhalten dieser Operatoren unterscheidet sich vom typischen Operatorverhalten bei Typen, die NULL-Werte zulassen. In der Regel kann ein Operator, der für Operanden eines Werttyps definiert ist, auch mit Operanden des entsprechenden Nullable-Typs verwendet werden. Ein solcher Operator generiert null, wenn einer seiner Operanden in null ausgewertet wird. Die &- und |-Operatoren können jedoch Nicht-NULL-Werte erzeugen, auch wenn einer der Operanden in null ausgewertet wird. Weitere Informationen zum Operatorverhalten bei Nullable-Werttypen finden Sie im Abschnitt „Lifted“ Operatoren des Artikels Nullable-Werttypen.

Sie können auch die !- und ^- Operatoren mit bool?-Operanden verwenden, wie das folgende Beispiel zeigt:

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.

Verbundzuweisung

Bei einem binären Operator op entspricht ein Verbundzuweisungsausdruck der Form

x op= y

Ist äquivalent zu

x = x op y

Mit der Ausnahme, dass x nur einmal ausgewertet wird.

Die &-, |- und ^-Operatoren unterstützen die Verbundzuweisung, wie das folgende Beispiel zeigt:

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

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

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

Hinweis

Die bedingten logischen Operatoren && und || unterstützen nicht die Verbundzuweisung.

Operatorrangfolge

In der folgenden Liste sind die logischen Operatoren beginnend mit dem höchsten Rangfolgenoperator absteigend sortiert:

• Logischer Negationsoperator !
• Logischer AND-Operator &
• Logischer exklusiver OR-Operator ^
• Logischer OR-Operator |
• Bedingter logischer AND-Operator &&
• Bedingter logischer OR-Operator ||

Verwenden Sie Klammern (), wenn Sie die Reihenfolge der Auswertung ändern möchten, die durch Operatorrangfolge festgelegt wird:

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.

Operatorüberladbarkeit

Ein benutzerdefinierter Typ kann die Operatoren , !, & und |^. Wenn ein binärer Operator überladen ist, wird der zugehörige Verbundzuweisungsoperator implizit auch überladen. Ab C# 14 kann ein benutzerdefinierter Typ die zusammengesetzten Zuordnungsoperatoren explizit überladen, um eine effizientere Implementierung bereitzustellen. In der Regel überlastet ein Typ diese Operatoren, da der Wert direkt aktualisiert werden kann, anstatt eine neue Instanz zuzuweisen, um das Ergebnis des binären Vorgangs zu speichern. Wenn ein Typ keine explizite Überladung bereitstellt, generiert der Compiler die implizite Überladung.

Ein benutzerdefinierter Typ kann die bedingten logischen Operatoren && und || nicht überladen. 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. Weitere Informationen finden Sie im Abschnitt Benutzerdefinierte bedingte logische Operatoren der C#-Sprachspezifikation.

C#-Sprachspezifikation

Weitere Informationen finden Sie in den folgenden Abschnitten der C#-Sprachspezifikation:

• Logischer Negationsoperator
• Logical operators (Logische Operatoren)
• Conditional logical operators (Bedingte logische Operatoren)
• Verbundzuweisung
• Benutzerdefinierte zusammengesetzte Zuweisung

Weitere Informationen

• C#-Operatoren und -Ausdrücke
• Bitweise und Schiebeoperatoren