Freigeben über

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 (||).

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

Die C#-Sprachreferenz dokumentiert die zuletzt veröffentlichte Version der C#-Sprache. Außerdem enthält sie eine erste Dokumentation zu Funktionen in der öffentlichen Vorschau für die kommende Sprachversion.

In der Dokumentation werden alle Features identifiziert, die in den letzten drei Versionen der Sprache oder in der aktuellen öffentlichen Vorschau eingeführt wurden.

Tipp

Informationen dazu, wann ein Feature erstmals in C# eingeführt wurde, finden Sie im Artikel zum Versionsverlauf der C#-Sprache.

Logischer Negationsoperator: !

Der unäre Präfixoperator ! berechnet die logische Negation des Operanden. Es erzeugt true , wenn der Operand ausgewertet falsewird, und false wenn der Operand zu true:

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 ytrue sind. Andernfalls ist das Ergebnis false.

Der &-Operator wertet immer beide Operanden aus. Wenn der linke Operand ist, ist falsefalse das Vorgangsergebnis unabhängig vom Wert des rechten Operanden. Der rechte Operand wird jedoch weiterhin 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 das logische AND seiner Operanden, wertet jedoch nicht den rechten Operanden aus, wenn der linke Operand ist false.

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 und yfalse ist, oder x ist false und y ist true. Andernfalls ist das Ergebnis false. Bei bool Operanden berechnet der ^ Operator dasselbe 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 das logische OR seiner Operanden, wertet den rechten Operanden jedoch nicht aus, wenn der linke Operand ausgewertet wird true.

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 das logische UND seiner Operanden, wertet aber immer beide Operanden aus.

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

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

  • Der & Operator gibt nur dann zurück true , wenn beide Operanden ausgewertet werden true. Wenn eine x der wertet falseoder y als , x & y gibt zurück false (auch wenn ein anderer Operand ausgewertet wirdnull). 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 Nullwerttyps 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:

Weitere Informationen

  • Last updated on