Operatori logici booleani: AND, OR, NOT, XOR

Gli operatori logici booleani eseguono operazioni logiche con gli operandi bool. Gli operatori includono la negazione logica unaria (!), la logica binaria AND (&), OR (|) e OR esclusivo (^) e la logica binaria condizionale AND (&&) e OR (||).

• Operatore unario ! (negazione logica).
• Operatori binari & (AND logico), | (OR logico) e ^ (OR esclusivo logico). Questi operatori valutano sempre entrambi gli operandi.
• Operatori binari && (AND condizionale logico) e || (OR condizionale logico). Questi operatori valutano l'operando di destra solo se è necessario.

Per gli operandi dei tipi numerici integrali, gli operatori &, | e ^ eseguono operazioni logiche bit per bit. Per altre informazioni, vedere Operatori di scorrimento e bit per bit.

Operatore di negazione logica !

L'operatore unario prefisso ! calcola la negazione logica del relativo operando. Vale a dire, produce true se l'operando restituisce false e false se l'operando restituisce true:

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

L'operatore unario suffisso ! è l'operatore null-forgiving.

Operatore logico AND &

L'operatore & calcola l'AND logico dei relativi operandi. Il risultato di x & y è true se x e y restituiscono true. In caso contrario, il risultato è false.

L'operatore & valuta sempre entrambi gli operandi. Quando l'operando di sinistra restituisce false, il risultato dell'operazione è false indipendentemente dal valore dell'operando di destra. Tuttavia, anche in questo caso, viene valutato l'operando di destra.

Nell'esempio seguente l'operando di destra dell'operatore & è una chiamata a un metodo, che viene eseguita indipendentemente dal valore dell'operando di sinistra:

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

L'operatore AND condizionale logico&& calcola anche l'AND logico dei relativi operandi, ma non valuta l'operando di destra se l'operando di sinistra restituisce false.

Per gli operandi dei tipi numerici integrali, l'operatore & calcola l'AND logico bit per bit dei relativi operandi. L'operatore unario & è l'operatore address-of.

Operatore OR esclusivo logico: ^

L'operatore ^ calcola l'OR esclusivo logico, noto anche come XOR logico, dei relativi operandi. Il risultato di x ^ y è true se x restituisce true e y restituisce false oppure x restituisce false e y restituisce true. In caso contrario, il risultato è false. Vale a dire, per gli operandi bool, l'operatore ^ calcola lo stesso risultato dell'operatore di disuguaglianza!=.

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

Per gli operandi dei tipi numerici integrali, l'operatore ^ calcola l'OR esclusivo logico bit per bit dei relativi operandi.

Operatore OR logico |

L'operatore | calcola l'OR logico dei relativi operandi. Il risultato di x | y è true se x o y restituisce true. In caso contrario, il risultato è false.

L'operatore | valuta sempre entrambi gli operandi. Quando l'operando di sinistra restituisce true, il risultato dell'operazione è true indipendentemente dal valore dell'operando di destra. Tuttavia, anche in questo caso, viene valutato l'operando di destra.

Nell'esempio seguente l'operando di destra dell'operatore | è una chiamata a un metodo, che viene eseguita indipendentemente dal valore dell'operando di sinistra:

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

L'operatore OR condizionale logico|| calcola anche l'OR logico dei relativi operandi, ma non valuta l'operando di destra se l'operando di sinistra restituisce true.

Per gli operandi dei tipi numerici integrali, l'operatore | calcola l'OR logico bit per bit dei relativi operandi.

Operatore AND logico condizionale &&

L'operatore AND condizionale logico &&, chiamato anche operatore AND logico di "corto circuito", calcola l'AND logico dei relativi operandi. Il risultato di x && y è true se x e y restituiscono true. In caso contrario, il risultato è false. Se x restituisce false, y non viene valutato.

Nell'esempio seguente l'operando di destra dell'operatore && è una chiamata a un metodo, che non viene eseguita se l'operando di sinistra restituisce 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

L'operatore AND logico& calcola anche l'AND logico dei relativi operandi, ma valuta sempre entrambi gli operandi.

Operatore OR condizionale logico ||

L'operatore OR condizionale logico ||, chiamato anche operatore OR logico di "corto circuito", calcola l'OR logico dei relativi operandi. Il risultato di x || y è true se x o y restituisce true. In caso contrario, il risultato è false. Se x restituisce true, y non viene valutato.

Nell'esempio seguente l'operando di destra dell'operatore || è una chiamata a un metodo, che non viene eseguita se l'operando di sinistra restituisce 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

L'operatore OR logico| calcola anche l'OR logico dei relativi operandi, ma valuta sempre entrambi gli operandi.

Operatori logici booleani nullable

Per gli operandi bool?, gli operatori & (AND logico) e | (OR logico) supportano la logica a tre valori come indicato di seguito:

• L'operatore & produce true solo se entrambi gli operandi restituiscono true. Se x o y restituisce false, x & y produce false (anche se un altro operando restituisce null). In caso contrario, il risultato di x & y è null.

• L'operatore | produce false solo se entrambi gli operandi restituiscono false. Se x o y restituisce true, x | y produce true (anche se un altro operando restituisce null). In caso contrario, il risultato di x | y è null.

La tabella seguente presenta tale semantica:

Il comportamento di questi operatori è diverso dal comportamento tipico degli operatori con tipi valore nullable. In genere un operatore definito per gli operandi di un tipo valore può essere usato anche con gli operandi del tipo valore che ammette i valori Null corrispondente. Un operatore di questo tipo produce null se uno qualsiasi dei relativi operandi restituisce null. Tuttavia gli operatori & e | possono produrre valori non Null anche se uno degli operandi restituisce null. Per altre informazioni sul comportamento degli operatori con i tipi valore che ammettono i valori Null, vedere la sezione Operatori con elevazione dell'articolo Tipi valore che ammettono i valori Null.

È anche possibile usare gli operatori ! e ^ con gli operandi bool?, come mostrato nell'esempio seguente:

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

Gli operatori logici condizionali && e || non supportano gli operandi bool?.

Assegnazione composta

Per un operatore binario op, un'espressione di assegnazione composta in formato

x op= y

equivale a

x = x op y

con la differenza che x viene valutato una sola volta.

Gli operatori &, | e ^ supportano l'assegnazione composta, come illustrato nell'esempio seguente:

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

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

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

Precedenza tra gli operatori

Nell'elenco seguente gli operatori logici sono ordinati dalla precedenza più elevata a quella più bassa:

• Operatore di negazione logico !
• Operatore AND logico &
• Operatore OR esclusivo logico ^
• Operatore OR logico |
• Operatore AND condizionale logico &&
• Operatore OR condizionale logico ||

Usare le parentesi, (), per cambiare l'ordine di valutazione imposto dalla precedenza tra gli operatori:

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

Per l'elenco completo degli operatori C# ordinati per livello di precedenza, vedere la sezione precedenza dell'operatore nell'articolo operatori C#.

Overload degli operatori

Un tipo definito dall'utente può eseguire l'overload degli operatori !, &, | e ^. Quando viene eseguito l'overload di un operatore binario, viene anche eseguito in modo implicito l'overload dell'operatore di assegnazione composta corrispondente. Un tipo definito dall'utente non può eseguire in modo esplicito l'overload di un operatore di assegnazione composta.

Un tipo definito dall'utente non può eseguire l'overload degli operatori logici condizionali && e ||. Tuttavia, se un tipo definito dall'utente esegue l'overload degli operatori true e false e dell'operatore & o | in un determinato modo, l'operazione && o || può essere valutata per gli operandi di quel tipo. Per altre informazioni, vedere la sezione Operatori logici condizionali definiti dall'utente di Specifica del linguaggio C#.

Specifiche del linguaggio C#

Per altre informazioni, vedere le sezioni seguenti delle specifiche del linguaggio C#:

• Operatore di negazione logica
• Operatori logici
• Operatori logici condizionali
• Assegnazione composta

Vedi anche

• Operatori ed espressioni C#
• Operatori di scorrimento e bit per bit