Dela via


Booleska logiska operatorer – AND, OR, NOT, XOR

De logiska booleska operatorerna utför logiska åtgärder med boolopernder . Operatorerna inkluderar unary logical negation (!), binary logical AND (&), OR (|) och exclusive OR (^) och binary conditional logical AND (&&) and OR (||).

För operander av de integrerade numeriska typerna& utför operatorerna , |och ^ bitvis logiska åtgärder. Mer information finns i Bitwise- och skiftoperatorer.

Logisk negationsoperator!

Den unary prefixoperatorn ! beräknar logisk negation av dess operand. Det innebär att den genererar true, om operanden utvärderas till false, och false, om operanden utvärderas till true:

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

Operatorn unary postfix ! är operatorn null-forgiving.

Logisk AND-operator &

Operatorn & beräknar logiska OCH för dess operander. Resultatet av x & y är true om både x och y utvärderas till true. Annars blir falseresultatet .

Operatorn & utvärderar alltid båda operanderna. När den vänstra operanden utvärderas till falseär false åtgärdsresultatet oavsett värdet för den högra operanden. Men även då utvärderas den högra operanden.

I följande exempel är operatorns & högra operand ett metodanrop som utförs oavsett värdet för den vänstra operanden:

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

Den villkorsstyrda logiska AND-operatorn&& beräknar också det logiska OCH för dess operander, men utvärderar inte den högra operanden om den vänstra operanden utvärderas till false.

För operander av de numeriska typerna beräknar operatorn & den bitvis logiska AND :n för dess operander. Den unary & operatorn är adress-of-operatorn.

Logisk exklusiv OR-operator ^

Operatorn ^ beräknar den logiska exklusiva OR, även kallad logisk XOR, för dess operander. Resultatet av x ^ y är true om x utvärderas till true och y utvärderas till false, eller x utvärderas till false och y utvärderas till true. Annars blir falseresultatet . bool För operanderna beräknar operatorn ^ alltså samma resultat som ojämlikhetsoperatorn!=.

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 operander av de integrerade numeriska typerna beräknar operatorn ^ den bitvis logiska exklusiva OR :n för dess operander.

Logisk OR-operator |

Operatorn | beräknar den logiska OR:en för dess operander. Resultatet av x | y är true om antingen x eller y utvärderas till true. Annars blir falseresultatet .

Operatorn | utvärderar alltid båda operanderna. När den vänstra operanden utvärderas till trueär true åtgärdsresultatet oavsett värdet för den högra operanden. Men även då utvärderas den högra operanden.

I följande exempel är operatorns | högra operand ett metodanrop som utförs oavsett värdet för den vänstra operanden:

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

Den villkorsstyrda logiska OR-operatorn|| beräknar också den logiska OR för dess operander, men utvärderar inte den högra operanden om den vänstra operanden utvärderas till true.

För operander av de integrerade numeriska typerna beräknar operatorn | den bitvis logiska OR :n för dess operander.

Villkorsstyrd logisk AND-operator &

Den villkorsstyrda logiska AND-operatorn &&, även känd som den logiska AND-operatorn "short-circuiting", beräknar logiska AND för dess operander. Resultatet av x && y är true om både x och y utvärderas till true. Annars blir falseresultatet . Om x utvärderas till falsey utvärderas inte.

I följande exempel är operatorns && högra operand ett metodanrop som inte utförs om den vänstra operanden utvärderas till 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

Den logiska AND-operatorn& beräknar också det logiska AND:et för dess operander, men utvärderar alltid båda operanderna.

Villkorsstyrd logisk OR-operator ||

Den villkorsstyrda logiska OR-operatorn ||, även kallad logisk OR-operator för kortslutning, beräknar den logiska OR:en för dess operander. Resultatet av x || y är true om antingen x eller y utvärderas till true. Annars blir falseresultatet . Om x utvärderas till truey utvärderas inte.

I följande exempel är operatorns || högra operand ett metodanrop som inte utförs om den vänstra operanden utvärderas till 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

Den logiska OR-operatorn| beräknar också den logiska OR för dess operander, men utvärderar alltid båda operanderna.

Booleska operatorer som kan ogiltigförklaras

För bool? operander stöder operatorerna&(logisk AND) och | (logisk OR) trevärdeslogik enligt följande:

  • Operatorn & producerar true endast om båda dess operander utvärderas till true. Om antingen x eller y utvärderas till falsex & y genererar false (även om en annan operand utvärderas till null). Annars är nullresultatet av x & y .

  • Operatorn | producerar false endast om båda dess operander utvärderas till false. Om antingen x eller y utvärderas till truex | y genererar true (även om en annan operand utvärderas till null). Annars är nullresultatet av x | y .

I följande tabell visas semantiken:

x y x&y x|y
true true true true
true falskt falskt true
true null null true
falskt true falskt true
falskt falskt falskt falskt
falskt NULL falskt null
null true NULL true
NULL falskt falskt null
null null null null

Beteendet för dessa operatorer skiljer sig från det typiska operatorbeteendet med nullbara värdetyper. Vanligtvis kan en operator som definieras för operander av en värdetyp också användas med operander av motsvarande null-värdetyp. En sådan operator producerar null om någon av dess operander utvärderas till null. Operatorerna & och | kan dock generera icke-null även om någon av operanderna utvärderas till null. Mer information om operatorbeteendet med typer av null-värden finns i avsnittet Lifted operatorer i artikeln Nullable value types (Ogiltiga värdetyper).

Du kan också använda operatorerna ! och ^ med bool? operander, som följande exempel visar:

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

De villkorsstyrda logiska operatorerna && och || stöder bool? inte operander.

Sammansatt tilldelning

För en binär operator op, ett sammansatt tilldelningsuttryck för formuläret

x op= y

motsvarar

x = x op y

förutom att x endast utvärderas en gång.

Operatorerna &, |och ^ stöder sammansatt tilldelning, vilket visas i följande exempel:

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

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

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

Kommentar

De villkorsstyrda logiska operatorerna && och || stöder inte sammansatt tilldelning.

Prioritet för operator

Följande lista beställer logiska operatorer från den högsta prioriteten till den lägsta:

  • Logisk negationsoperator !
  • Logisk AND-operator &
  • Logisk exklusiv OR-operator ^
  • Logisk OR-operator |
  • Villkorsstyrd logisk AND-operator &&
  • Villkorsstyrd logisk OR-operator ||

Använd parenteser, (), för att ändra ordningen på utvärderingen som har införts av operatorprioriteten:

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

En fullständig lista över C#-operatorer ordnade efter prioritetsnivå finns i avsnittet Operatorprioriteten i artikeln C#-operatorer .

Överlagring av operator

En användardefinierad typ kan överbelasta operatorerna !, &, |och ^ . När en binär operator är överbelastad överbelastas även motsvarande sammansatta tilldelningsoperator implicit. En användardefinierad typ kan inte uttryckligen överbelasta en sammansatt tilldelningsoperator.

En användardefinierad typ kan inte överbelasta de villkorsstyrda logiska operatorerna && och ||. Men om en användardefinierad typ överbelastar de sanna och falska operatorerna och & operatorn eller | på ett visst sätt, && kan åtgärden eller || utvärderas för operanderna av den typen. Mer information finns i avsnittet Användardefinierade villkorsstyrda logiska operatorer i C#-språkspecifikationen.

Språkspecifikation för C#

Mer information finns i följande avsnitt i C#-språkspecifikationen:

Se även