Operadores lógicos boolianos – AND, OR, NOT, XOR

Os operadores bolianos lógicos executam operações lógicas com operandos bool. Os operadores incluem a negação lógica unária (!), AND lógico binário (&), OR (|) e OR exclusivo (^) e os lógicos condicionais binários AND (&&) e OR (||).

• Operador unário ! (negação lógica).
• Operadores binários & (AND lógico), | (OR lógico) e ^ (OR exclusivo lógico). Esses operadores sempre avaliam os dois operandos.
• Operadores binários && (AND lógico condicional) e || (OR lógico condicional). Esses operadores avaliam o operando à direita apenas se for necessário.

Para os operandos dos tipos numéricos integrais, os operadores &, | e ^ executam operações lógicas bit a bit. Para obter mais informações, veja Operadores bit a bit e shift.

Operador de negação lógica !

O prefixo unário ! calcula a negação lógica de seu operando. Ou seja, ele produz true, se o operando for avaliado como false, e false, se o operando for avaliado como true:

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

O operador ! de sufixo unário é o operador de perdão nulo.

Operador AND lógico &

O operador & computa o AND lógico de seus operandos. O resultado de x & y será true se ambos x e y forem avaliados como true. Caso contrário, o resultado será false.

O operador & sempre avalia ambos os operandos. Quando o operando esquerdo é avaliado como false, o resultado da operação é false independentemente do valor do operando à direita. No entanto, mesmo assim, o operando à direita é avaliado.

No exemplo a seguir, o operando à direita do operador & é uma chamada de método, que é executada independentemente do valor do operando à esquerda:

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

O operador AND lógico condicional && também computa o AND lógico e seus operandos, mas não avalia o operando à direita se o operando à esquerda for avaliado como false.

Para os operandos de tipos numéricos integrais, o operador & computa o AND lógico bit a bit de seus operandos. O operador & unário é o operador address-of.

Operador OR exclusivo lógico ^

O operador ^ computa o OR exclusivo lógico, também conhecido como o XOR lógico, de seus operandos. O resultado de x ^ y é true se x é avaliado como true e y avaliado como false, ou x avaliado como false e y avaliado como true. Caso contrário, o resultado será false. Ou seja, para os operandos bool, o operador ^ computa o mesmo resultado que o operador de desigualdade !=.

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

Para os operandos de tipos numéricos integrais, o operador ^ computa o OR exclusivo lógico bit a bit de seus operandos.

Operador OR lógico |

O operador | computa o OR lógico de seus operandos. O resultado de x | y será true se x ou y for avaliado como true. Caso contrário, o resultado será false.

O operador | sempre avalia ambos os operandos. Quando o operando esquerdo é avaliado como true, o resultado da operação é true independentemente do valor do operando à direita. No entanto, mesmo assim, o operando à direita é avaliado.

No exemplo a seguir, o operando à direita do operador | é uma chamada de método, que é executada independentemente do valor do operando à esquerda:

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

O operador OR lógico condicional || também computa o OR lógico e seus operandos, mas não avalia o operando à direita se o operando à esquerda for avaliado como true.

Para os operandos de tipos numéricos integrais, o operador | computa o OR lógico bit a bit de seus operandos.

Operador AND lógico condicional &&

O operador AND lógico condicional &&, também conhecido como operador AND lógico de "curto-circuito", computa o AND lógico de seus operandos. O resultado de x && y será true se ambos x e y forem avaliados como true. Caso contrário, o resultado será false. Se x for avaliado como false, y não será avaliado.

No exemplo a seguir, o operando à direita do operador && é uma chamada de método, que não é executada se o operando à esquerda for avaliado como 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

O operador AND lógico & também computa o AND lógico de seus operandos, mas sempre avalia os dois operandos.

Operador OR lógico condicional ||

O operador OR lógico condicional ||, também conhecido como operador OR lógico de "curto-circuito", computa o OR lógico de seus operandos. O resultado de x || y será true se x ou y for avaliado como true. Caso contrário, o resultado será false. Se x for avaliado como true, y não será avaliado.

No exemplo a seguir, o operando à direita do operador || é uma chamada de método, que não é executada se o operando à esquerda for avaliado como 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

O operador OR lógico | também computa o OR lógico de seus operandos, mas sempre avalia os dois operandos.

Operadores lógicos booleanos anuláveis

Para operandos bool?, os operadores & (AND lógico) e | (OR lógico) dão suporte à lógica de três valores da seguinte maneira:

• O operador & produz true somente se ambos os operandos forem avaliados como true. Se x ou y forem avaliados como false, x & y produzirá false (mesmo que outro operando seja avaliado como null). Caso contrário, o resultado de x & y será null.

• O operador | produz false somente se ambos os operandos forem avaliados como false. Se x ou y forem avaliados como true, x | y produzirá true (mesmo que outro operando seja avaliado como null). Caso contrário, o resultado de x | y será null.

A tabela a seguir apresenta essa semântica:

x	a	x&y	x|y
true	true	true	true
true	false	false	true
true	nulo	null	true
false	true	false	true
false	false	false	false
false	nulo	false	nulo
null	true	null	true
nulo	false	false	nulo
nulo	nulo	nulo	nulo

O comportamento desses operadores difere do comportamento típico do operador com tipos de valores anuláveis. Normalmente, um operador definido para operandos de um tipo de valor também pode ser usado com operandos do tipo de valor anulável correspondente. Esse operador produz null se algum de seus operandos avaliar para null. No entanto, os operadores & e | podem produzir não nulos, mesmo se um dos operandos avaliar para null. Para obter mais informações sobre o comportamento do operador com tipos de valor nulos, confira a seção Operadores suspensos no artigo Tipos de valor anulável.

Você também pode usar os operadores ! e ^ com os operandos bool?, como mostra o exemplo a seguir:

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

Os operadores lógicos condicionais && e || não oferecem suporte a operandos bool?.

Atribuição composta

Para um operador binário op, uma expressão de atribuição composta do formato

x op= y

é equivalente a

x = x op y

exceto que x é avaliado apenas uma vez.

Os operadores &, | e ^ suportam a atribuição de compostos, conforme mostrado no exemplo a seguir:

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

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

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

Observação

Os operadores lógicos condicionais && e || não suportam a atribuição composta.

Precedência do operador

A lista a seguir ordena os operadores lógicos, começando da mais alta precedência até a mais baixa:

• Operador de negação lógica !
• Operador AND lógico &
• Operador OR exclusivo lógico ^
• Operador OR lógico |
• Operador AND lógico condicional &&
• Operador OR lógico condicional ||

Use parênteses, (), para alterar a ordem de avaliação imposta pela precedência do operador:

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

Para obter a lista completa de operadores C# ordenados por nível de precedência, consulte a seção Precedência de operador do artigo Operadores C# .

Capacidade de sobrecarga do operador

Os tipos definidos pelo usuário podem sobrecarregar os operadores !, &, | e ^. Quando um operador binário está sobrecarregado, o operador de atribuição composta correspondente também é implicitamente sobrecarregado. Um tipo definido pelo usuário não pode sobrecarregar explicitamente um operador de atribuição composta.

Um tipo definido pelo usuário não pode sobrecarregar os operadores lógicos condicionais && e ||. No entanto, se um tipo definido pelo usuário sobrecarregar os operadores true e false e o operador & ou | de uma determinada maneira, a operação && ou ||, respectivamente, pode ser avaliada para os operandos desse tipo. Para obter mais informações, veja a seção Operadores lógicos condicionais definidos pelo usuário na especificação da linguagem C#.

Especificação da linguagem C#

Para obter mais informações, confira as seguintes seções da especificação da linguagem C#:

• Operador de negação lógica
• Operadores lógicos
• Operadores lógicos condicionais
• Atribuição composta

Confira também

• Operadores e expressões C#
• Operadores shift e bit a bit