Operatori logici booleani (Riferimenti per C#)Boolean logical operators (C# reference)

Gli operatori seguenti eseguono operazioni logiche con operandi bool :The following operators perform logical operations with bool operands:

Per gli operandi dei tipi numerici integrali, gli & | operatori, e ^ eseguono operazioni logiche bit per bit.For operands of the integral numeric types, the &, |, and ^ operators perform bitwise logical operations. Per altre informazioni, vedere Operatori di scorrimento e bit per bit.For more information, see Bitwise and shift operators.

Operatore di negazione logica !Logical negation operator !

L'operatore di prefisso unario ! Calcola la negazione logica del relativo operando.The unary prefix ! operator computes logical negation of its operand. Vale a dire, produce true se l'operando restituisce false e false se l'operando restituisce true:That is, it produces true, if the operand evaluates to false, and false, if the operand evaluates to true:

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

A partire da C# 8,0, l'operatore unario di suffisso ! è l' operatore che perdona i valori null.Beginning with C# 8.0, the unary postfix ! operator is the null-forgiving operator.

Operatore AND logico&Logical AND operator &

L'operatore & calcola l'AND logico dei relativi operandi.The & operator computes the logical AND of its operands. Il risultato di x & y è true se x e y restituiscono true.The result of x & y is true if both x and y evaluate to true. In caso contrario, il risultato è false.Otherwise, the result is false.

L' & operatore valuta entrambi gli operandi anche se l'operando sinistro restituisce false , in modo che il risultato dell'operazione sia false indipendentemente dal valore dell'operando destro.The & operator evaluates both operands even if the left-hand operand evaluates to false, so that the operation result is false regardless of the value of the right-hand operand.

Nell'esempio seguente l'operando di destra dell'operatore & è una chiamata a un metodo, che viene eseguita indipendentemente dal valore dell'operando di sinistra:In the following example, the right-hand operand of the & operator is a method call, which is performed regardless of the value of the left-hand operand:

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.The conditional logical AND operator && also computes the logical AND of its operands, but doesn't evaluate the right-hand operand if the left-hand operand evaluates to false.

Per gli operandi dei tipi numerici integrali, l' & operatore calcola l' and logico bit per bit dei relativi operandi.For operands of the integral numeric types, the & operator computes the bitwise logical AND of its operands. L'operatore unario & è l'operatore address-of.The unary & operator is the address-of operator.

Operatore OR esclusivo logico: ^Logical exclusive OR operator ^

L'operatore ^ calcola l'OR esclusivo logico, noto anche come XOR logico, dei relativi operandi.The ^ operator computes the logical exclusive OR, also known as the logical XOR, of its operands. Il risultato di x ^ y è true se x restituisce true e y restituisce false oppure x restituisce false e y restituisce true.The result of x ^ y is true if x evaluates to true and y evaluates to false, or x evaluates to false and y evaluates to true. In caso contrario, il risultato è false.Otherwise, the result is false. Vale a dire, per gli operandi bool, l'operatore ^ calcola lo stesso risultato dell'operatore di disuguaglianza !=.That is, for the bool operands, the ^ operator computes the same result as the inequality operator !=.

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.For operands of the integral numeric types, the ^ operator computes the bitwise logical exclusive OR of its operands.

Operatore OR logico |Logical OR operator |

L'operatore | calcola l'OR logico dei relativi operandi.The | operator computes the logical OR of its operands. Il risultato di x | y è true se x o y restituisce true.The result of x | y is true if either x or y evaluates to true. In caso contrario, il risultato è false.Otherwise, the result is false.

L' | operatore valuta entrambi gli operandi anche se l'operando sinistro restituisce true , in modo che il risultato dell'operazione sia true indipendentemente dal valore dell'operando destro.The | operator evaluates both operands even if the left-hand operand evaluates to true, so that the operation result is true regardless of the value of the right-hand operand.

Nell'esempio seguente l'operando di destra dell'operatore | è una chiamata a un metodo, che viene eseguita indipendentemente dal valore dell'operando di sinistra:In the following example, the right-hand operand of the | operator is a method call, which is performed regardless of the value of the left-hand operand:

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.The conditional logical OR operator || also computes the logical OR of its operands, but doesn't evaluate the right-hand operand if the left-hand operand evaluates to true.

Per gli operandi dei tipi numerici integrali, l' | operatore calcola l' OR logico bit per bit dei relativi operandi.For operands of the integral numeric types, the | operator computes the bitwise logical OR of its operands.

Operatore logico AND condizionale&&Conditional logical AND operator &&

L'operatore AND condizionale logico &&, chiamato anche operatore AND logico di "corto circuito", calcola l'AND logico dei relativi operandi.The conditional logical AND operator &&, also known as the "short-circuiting" logical AND operator, computes the logical AND of its operands. Il risultato di x && y è true se x e y restituiscono true.The result of x && y is true if both x and y evaluate to true. In caso contrario, il risultato è false.Otherwise, the result is false. Se x è false, y non viene valutato.If x evaluates to false, y is not evaluated.

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:In the following example, the right-hand operand of the && operator is a method call, which isn't performed if the left-hand operand evaluates to 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 logico and & Calcola anche l'and logico degli operandi, ma valuta sempre entrambi gli operandi.The logical AND operator & also computes the logical AND of its operands, but always evaluates both operands.

Operatore OR condizionale logico ||Conditional logical OR operator ||

L'operatore OR condizionale logico ||, chiamato anche operatore OR logico di "corto circuito", calcola l'OR logico dei relativi operandi.The conditional logical OR operator ||, also known as the "short-circuiting" logical OR operator, computes the logical OR of its operands. Il risultato di x || y è true se x o y restituisce true.The result of x || y is true if either x or y evaluates to true. In caso contrario, il risultato è false.Otherwise, the result is false. Se x è true, y non viene valutato.If x evaluates to true, y is not evaluated.

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:In the following example, the right-hand operand of the || operator is a method call, which isn't performed if the left-hand operand evaluates to 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 degli operandi, ma valuta sempre entrambi gli operandi.The logical OR operator | also computes the logical OR of its operands, but always evaluates both operands.

Operatori logici booleani nullableNullable Boolean logical operators

Per gli bool? operandi, gli operatori & (and logico) e | (OR logico) supportano la logica a tre valori come segue:For bool? operands, the & (logical AND) and | (logical OR) operators support the three-valued logic as follows:

  • L' & operatore produce true solo se entrambi gli operandi restituiscono true .The & operator produces true only if both its operands evaluate to true. Se x o y restituisce false , x & y produce false (anche se un altro operando restituisce null ).If either x or y evaluates to false, x & y produces false (even if another operand evaluates to null). In caso contrario, il risultato di x & y è null .Otherwise, the result of x & y is null.

  • L' | operatore produce false solo se entrambi gli operandi restituiscono false .The | operator produces false only if both its operands evaluate to false. Se x o y restituisce true , x | y produce true (anche se un altro operando restituisce null ).If either x or y evaluates to true, x | y produces true (even if another operand evaluates to null). In caso contrario, il risultato di x | y è null .Otherwise, the result of x | y is null.

Nella tabella seguente viene illustrata la semantica:The following table presents that semantics:

xx yy x&yx&y x|yx|y
truetrue truetrue truetrue truetrue
truetrue falsefalse falsefalse truetrue
truetrue Nullnull Nullnull truetrue
falsefalse truetrue falsefalse truetrue
falsefalse falsefalse falsefalse falsefalse
falsefalse Nullnull falsefalse Nullnull
Nullnull truetrue Nullnull truetrue
Nullnull falsefalse falsefalse Nullnull
Nullnull Nullnull Nullnull Nullnull

Il comportamento di questi operatori è diverso dal comportamento tipico degli operatori con tipi valore nullable.The behavior of those operators differs from the typical operator behavior with nullable value types. In genere un operatore definito per gli operandi di un tipo valore può essere usato anche con gli operandi del tipo valore nullable corrispondente.Typically, an operator which is defined for operands of a value type can be also used with operands of the corresponding nullable value type. Questo operatore produce null se uno qualsiasi degli operandi restituisce null .Such an operator produces null if any of its operands evaluates to null. Tuttavia, gli & | operatori e possono produrre un valore diverso da null anche se uno degli operandi restituisce null .However, the & and | operators can produce non-null even if one of the operands evaluates to null. Per ulteriori informazioni sul comportamento dell'operatore con i tipi di valore Nullable, vedere la sezione operatori rimossi dell'articolo tipi di valore Nullable .For more information about the operator behavior with nullable value types, see the Lifted operators section of the Nullable value types article.

È anche possibile usare gli ! ^ operatori e con bool? operandi, come illustrato nell'esempio seguente:You can also use the ! and ^ operators with bool? operands, as the following example shows:

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 bool? operandi.The conditional logical operators && and || don't support bool? operands.

Assegnazione compostaCompound assignment

Per un operatore binario op, un'espressione di assegnazione composta in formatoFor a binary operator op, a compound assignment expression of the form

x op= y

equivale ais equivalent to

x = x op y

con la differenza che x viene valutato una sola volta.except that x is only evaluated once.

Gli operatori &, | e ^ supportano l'assegnazione composta, come illustrato nell'esempio seguente:The &, |, and ^ operators support compound assignment, as the following example shows:

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

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

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

Nota

Gli operatori condizionali logici && e || non supportano l'assegnazione composta.The conditional logical operators && and || don't support compound assignment.

Precedenza degli operatoriOperator precedence

Nell'elenco seguente gli operatori logici sono ordinati dalla precedenza più elevata a quella più bassa:The following list orders logical operators starting from the highest precedence to the lowest:

  • Operatore di negazione logico !Logical negation operator !
  • Operatore AND logico &Logical AND operator &
  • Operatore OR esclusivo logico ^Logical exclusive OR operator ^
  • Operatore OR logico |Logical OR operator |
  • Operatore AND condizionale logico &&Conditional logical AND operator &&
  • Operatore OR condizionale logico ||Conditional logical OR operator ||

Usare le parentesi, (), per cambiare l'ordine di valutazione imposto dalla precedenza tra gli operatori:Use parentheses, (), to change the order of evaluation imposed by operator precedence:

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 in base al livello di precedenza, vedere la sezione precedenza degli operatori dell'articolo operatori c# .For the complete list of C# operators ordered by precedence level, see the Operator precedence section of the C# operators article.

Overload degli operatoriOperator overloadability

Un tipo definito dall'utente può eseguire l' Overload degli ! operatori, & , | e ^ .A user-defined type can overload the !, &, |, and ^ operators. Quando viene eseguito l'overload di un operatore binario, viene anche eseguito in modo implicito l'overload dell'operatore di assegnazione composta corrispondente.When a binary operator is overloaded, the corresponding compound assignment operator is also implicitly overloaded. Un tipo definito dall'utente non può eseguire in modo esplicito l'overload di un operatore di assegnazione composta.A user-defined type cannot explicitly overload a compound assignment operator.

Un tipo definito dall'utente non può eseguire l'overload degli operatori condizionali logici && e ||.A user-defined type cannot overload the conditional logical operators && and ||. 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.However, if a user-defined type overloads the true and false operators and the & or | operator in a certain way, the && or || operation, respectively, can be evaluated for the operands of that type. Per altre informazioni, vedere la sezione Operatori logici condizionali definiti dall'utente di Specifica del linguaggio C#.For more information, see the User-defined conditional logical operators section of the C# language specification.

Specifiche del linguaggio C#C# language specification

Per altre informazioni, vedere le sezioni seguenti delle specifiche del linguaggio C#:For more information, see the following sections of the C# language specification:

Vedere ancheSee also