Operadores lógicos boolianos (referência do C#)

Os operadores a seguir executam operações lógicas com operandos bool :

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

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

Operador de negação lógica !

O operador de prefixo ! unário computa 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

A partir do C# 8,0, o operador de sufixo ! unário é o !.

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 avalia os dois operandos mesmo se o operando esquerdo for avaliado false , de modo que o resultado da operação seja false independente do valor do operando à direita.

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 operandos dos tipos numéricos inteiros, o operador computa a lógica e os opera bits de bit e de seus operando. O operador & unário é o &.

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 bool operandos, o ^ operador computa o mesmo resultado que o operador != de bool.

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 operandos dos tipos numéricos inteiros, o operador computa o bit lógico Exclusive ou 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 avalia os dois operandos mesmo se o operando esquerdo for avaliado true , de modo que o resultado da operação seja true independente do valor do operando à direita.

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 dos tipos numéricos inteiros, o operador computa o bit lógico ou 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 bool? operandos, os bool? e & ) oferecem suporte à lógica de três valores, da seguinte maneira:

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

  • O | operador só produzirá false se ambos os operandos forem avaliados como false . xSe ou y for avaliada como true , x | y produz true (mesmo que outro operando seja avaliado como null ). Caso contrário, o resultado de x | y é 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 que é definido para operandos de um tipo de valor também pode ser usado com operandos do tipo de valor anulável correspondente. Tal operador produz null se qualquer um de seus operandos é avaliado como null . No entanto, os & operadores e | podem produzir não nulo mesmo se um dos operandos for avaliado como null . Para obter mais informações sobre o comportamento do operador com tipos de valores anuláveis, consulte a seção operadores levantados do artigo tipos de valores anuláveis .

Você também pode usar os ! operadores e ^ com bool? operandos, 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 dão suporte bool? a operandos.

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 sobre operadores do c# .

Capacidade de sobrecarga do operador

Um tipo definido pelo usuário pode 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#:

Confira também