Logikai operátorok – AND, OR, NOT, XOR

A logikai logikai operátorok logikai műveleteket hajtanak végre bool operandusokkal. Az operátorok közé tartozik a nem kötelező logikai tagadás (!), a bináris logikai ÉS (), VAGY (&|) és a kizárólagos VAGY (^), valamint a bináris feltételes logikai ÉS (&&) és AZ (||).

• Unary ! (logikai tagadás) operátor.
• Bináris & (logikai ÉS), | (logikai VAGY) és ^ (logikai kizáró VAGY) operátorok. Ezek az operátorok mindig mindkét operandust értékelik.
• Bináris && (feltételes logikai ÉS) és || (feltételes logikai VAGY) operátorok. Ezek az operátorok csak akkor értékelik ki a jobb oldali operandust, ha szükséges.

Az integrál numerikus típusok operandusai esetében a , &és | az ^operátorok bitenkénti logikai műveleteket hajtanak végre. További információ: Bitwise és shift operátorok.

Logikai negation operátor !

A unary prefix ! operátor az operandus logikai eltagolását számítja ki. Ez azt jelzi, hogy az operandus truea következő értéket adjafalse, és falseha az operandus a következőt trueértékeli ki:

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

A unary postfix ! operátor a null-elbocsátó operátor.

Logikai ÉS operátor >

Az & operátor kiszámítja a logikai ÉS operandusait. Ennek eredményex & y, ha mindkettőtrue, és x a kiértékelés eredménye.ytrue Ellenkező esetben az eredmény a következő false: .

Az & operátor mindig mindkét operandust kiértékeli. Amikor a bal oldali operandus kiértékeli, falsea művelet eredménye a jobb oldali operandus értékétől függetlenül lesz false . A jobb oldali operandus azonban még akkor is kiértékelésre kerül.

Az alábbi példában az operátor jobb oldali operandusa & egy metódushívás, amelyet a bal oldali operandus értékétől függetlenül hajtunk végre:

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

A feltételes logikai ÉS operátor&& a logikai ÉS operandusait is kiszámítja, de nem értékeli ki a jobb oldali operandust, ha a bal oldali operandus kiértékeli a következőt false: .

Az integrál numerikus típusok operandusai esetében az operátor kiszámítja a & operandusait. Az unary & operátor az operátor címe.

Logikai kizárólagos VAGY operátor ^

Az ^ operátor kiszámítja az operandusok logikai kizárólagos vagy más néven logikai XOR-ját. Az eredmény x ^ y az, true ha x kiértékeli azt true , majd yfalsekiértékeli azt , vagy x kiértékeli false és y kiértékeli.true Ellenkező esetben az eredmény a következő false: . Vagyis az bool operandusok esetében az ^ operátor ugyanazt az eredményt számítja ki, mint az egyenlőtlenségi operátor!=.

Console.WriteLine(true ^ true);    // output: False
Console.WriteLine(true ^ false);   // output: True
Console.WriteLine(false ^ true);   // output: True
Console.WriteLine(false ^ false);  // output: False

Az integrál numerikus típusok operandusai esetében az operátor kiszámítja az ^ operandusait.

Logikai VAGY operátor |

Az | operátor kiszámítja a logikai VAGY annak operandusait. Az eredmény x | y az, true ha vagy x a y kiértékelése true. Ellenkező esetben az eredmény a következő false: .

Az | operátor mindig mindkét operandust kiértékeli. Amikor a bal oldali operandus kiértékeli, truea művelet eredménye a jobb oldali operandus értékétől függetlenül lesz true . A jobb oldali operandus azonban még akkor is kiértékelésre kerül.

Az alábbi példában az operátor jobb oldali operandusa | egy metódushívás, amelyet a bal oldali operandus értékétől függetlenül hajtunk végre:

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

A feltételes logikai VAGY operátor|| a logikai VAGY operandusait is kiszámítja, de nem értékeli ki a jobb oldali operandust, ha a bal oldali operandus kiértékeli a következőt true: .

Az integrál numerikus típusok operandusai esetében az operátor kiszámítja a | operandusokat.

Feltételes logikai ÉS operátor >

A feltételes logikai AND operátor &&, más néven "rövidzárolás" logikai ÉS operátor, kiszámítja a logikai ÉS operandusait. Ennek eredményex && y, ha mindkettőtrue, és x a kiértékelés eredménye.ytrue Ellenkező esetben az eredmény a következő false: . Ha x a kiértékelés eredménye false, y akkor a kiértékelés nem történik meg.

Az alábbi példában az operátor jobb oldali operandusa && egy metódushívás, amely nem történik meg, ha a bal oldali operandus a következőt falseértékeli ki:

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

A logikai ÉS operátor& a logikai ÉS operandusait is kiszámítja, de mindig mindkét operandust kiértékeli.

Feltételes logikai VAGY operátor ||

A feltételes logikai VAGY operátor ||, más néven "rövidzárolás" logikai VAGY operátor, kiszámítja a logikai VAGY operandusait. Az eredmény x || y az, true ha vagy x a y kiértékelése true. Ellenkező esetben az eredmény a következő false: . Ha x a kiértékelés eredménye true, y akkor a kiértékelés nem történik meg.

Az alábbi példában az operátor jobb oldali operandusa || egy metódushívás, amely nem történik meg, ha a bal oldali operandus a következőt trueértékeli ki:

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

A logikai VAGY operátor| szintén kiszámítja az operandusok logikai vagy operandusait, de mindig mindkét operandust kiértékeli.

Null értékű logikai logikai operátorok

Az operandusok esetében bool? a & (logikai ÉS) és | (logikai VAGY) operátorok az alábbiak szerint támogatják a háromértékű logikát:

• Az & operátor csak akkor termel, true ha mindkét operandusa kiértékeli a következőt true: . Ha vagy x vagy y kiértékeli azt false, x & y akkor is létrejön false (még akkor is, ha egy másik operandus kiértékeli).null Ellenkező esetben az eredmény x & y az .null

• Az | operátor csak akkor termel, false ha mindkét operandusa kiértékeli a következőt false: . Ha vagy x vagy y kiértékeli azt true, x | y akkor is létrejön true (még akkor is, ha egy másik operandus kiértékeli).null Ellenkező esetben az eredmény x | y az .null

Az alábbi táblázat bemutatja ezt a szemantikát:

x	y	x és y	x | y
igaz	igaz	igaz	igaz
igaz	hamis	hamis	igaz
igaz	null	null	igaz
hamis	igaz	hamis	igaz
hamis	hamis	hamis	hamis
hamis	null	hamis	null
null	igaz	null	igaz
null	hamis	hamis	null
null	null	null	null

Ezeknek az operátoroknak a viselkedése eltér a null értékű operátorok tipikus viselkedésétől. Az érték típusú operandusokhoz definiált operátorok általában a megfelelő null értékű operandusokkal is használhatók. Egy ilyen operátor akkor termel, null ha bármelyik operandusa kiértékeli .null Az és & az | operátorok azonban akkor is létrehozhatnak nem null értéket, ha az operandusok egyike kiértékeli a következőtnull: . A null értékű értéktípusok operátori viselkedésével kapcsolatos további információkért lásd a Null értékű értéktípusok cikk Emelt operátorok szakaszát.

Operandusokkal ! is használhatja az operátorokat és az ^bool? operátorokat, ahogy az alábbi példa is mutatja:

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

A feltételes logikai operátorok &&|| nem támogatják bool? az operandusokat.

Összetett hozzárendelés

Bináris operátor opesetén az űrlap összetett hozzárendelési kifejezése

x op= y

Egyenértékű azzal, hogy

x = x op y

Kivéve, hogy a x csak egyszer lesz kiértékelve.

A &, |és ^ operátorok támogatják az összetett hozzárendelést, ahogy az alábbi példa is mutatja:

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

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

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

Feljegyzés

A feltételes logikai operátorok && , és || nem támogatják az összetett hozzárendelést.

Operátorok műveleti sorrendje

Az alábbi lista a logikai operátorokat a legmagasabb prioritástól a legalacsonyabbig rendeli:

• Logikai negation operátor !
• Logikai ÉS operátor &
• Logikai kizárólagos VAGY operátor ^
• Logikai VAGY operátor |
• Feltételes logikai ÉS operátor &&
• Feltételes logikai VAGY operátor ||

Zárójelek ()használatával módosítsa az operátorok elsőbbsége által előírt kiértékelési sorrendet:

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

A C#-operátorok elsőbbségi szint szerint rendezett teljes listájáért tekintse meg a C# operátorok cikkének Operátorok elsőbbsége című szakaszát.

Operátorok túlterhelése

A felhasználó által definiált típus túlterhelheti a !, &, |és ^ operátorokat. Ha egy bináris operátor túlterhelt, a megfelelő összetett hozzárendelési operátor is implicit módon túlterhelt. A C# 14-től kezdve a felhasználó által definiált típus explicit módon túlterhelheti az összetett hozzárendelési operátorokat a hatékonyabb megvalósítás érdekében. Egy típus általában túlterheli ezeket az operátorokat, mert az érték frissíthető a helyén, ahelyett, hogy egy új példányt helyeznek ki a bináris művelet eredményének tárolására. Ha egy típus nem biztosít explicit túlterhelést, a fordító implicit túlterhelést hoz létre.

A felhasználó által definiált típus nem tudja túlterhelni a feltételes logikai operátorokat && és ||a . Ha azonban egy felhasználó által definiált típus túlterheli a valódi és a hamis operátorokat , illetve az & operátort | egy bizonyos módon, akkor az && adott típusú operandusok esetében a művelet vagy || a művelet kiértékelhető. További információ: A C# nyelv specifikációjának felhasználó által definiált feltételes logikai operátorok szakasza.

C# nyelvspecifikáció

További információt a C# nyelvspecifikációjának alábbi szakaszaiban talál:

• Logikai negation operátor
• Logikai operátorok
• Feltételes logikai operátorok
• Összetett hozzárendelés
• Felhasználó által definiált összetett hozzárendelés

Lásd még

• C# operátorok és kifejezések
• Bitenkénti és shift operátorok