Operadores lógicos booleanos: AND, OR, NOT, XOR

Los operadores booleanos lógicos realizan operaciones lógicas con operandos bool. Los operadores incluyen la negación lógica unaria (!), AND lógico binario (&), OR (|) y OR exclusivo (^) y los AND (&&) y OR (||) lógicos condicionales binarios.

• Operador unario ! (negación lógica).
• Operadores binarios & (AND lógico), | (OR lógico) y ^ (OR exclusivo lógico). Esos operadores siempre evalúan ambos operandos.
• Operadores binarios && (AND lógico condicional) y || (OR lógico condicional). Esos operadores evalúan el operando derecho solo si es necesario.

En el caso de los operandos de los tipos numéricos enteros, los operadores &, | y ^ realizan operaciones lógicas bit a bit. Para obtener más información, vea Operadores de desplazamiento y bit a bit.

La documentación de referencia del lenguaje C# cubre la versión más reciente publicada del lenguaje C#. También contiene documentación inicial sobre las características de las versiones preliminares públicas de la próxima versión del lenguaje.

La documentación identifica cualquier característica introducida por primera vez en las últimas tres versiones del idioma o en las versiones preliminares públicas actuales.

Sugerencia

Para buscar cuándo se introdujo por primera vez una característica en C#, consulte el artículo sobre el historial de versiones del lenguaje C#.

Operador de negación lógico !

El operador de prefijo ! unario calcula la negación lógica de su operando. true Genera si el operando se evalúa como falsey false si el operando se evalúa como true:

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

El operador ! de postfijo unario es un operador que permite un valor NULL.

Operador lógico AND &

El operador & calcula el operador AND lógico de sus operandos. El resultado de x & y es true si tanto x como y son true. De lo contrario, el resultado es false.

El operador & siempre evalúa ambos operandos. Cuando el operando izquierdo es false, el resultado de la operación es false independientemente del valor del operando derecho. Sin embargo, el operando derecho todavía se evalúa.

En el ejemplo siguiente, el operando derecho del & operador es una llamada de método, que se ejecuta independientemente del valor del operando izquierdo:

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

El operador &&AND lógico condicional también calcula el AND lógico de sus operandos, pero no evalúa el operando derecho si el operando izquierdo es false.

En el caso de los operandos de los tipos numéricos enteros, el operador & calcula el AND lógico bit a bit de sus operandos. El operador & unario es el operador address-of.

Operador IR exclusivo lógico ^

El operador ^ calcula el operador OR exclusivo lógica, también conocido como el operador XOR lógico, de sus operandos. El resultado de x ^ y es true si x es true y y es false, o x es false y y es true. De lo contrario, el resultado es false. En bool el caso de los operandos, el ^ operador calcula el mismo resultado que el operador!= de desigualdad.

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

En el caso de los operandos de los tipos numéricos enteros, el operador ^ calcula el AND lógico bit a bit de sus operandos.

Operador lógico OR |

El operador | calcula el operador OR lógico de sus operandos. El resultado de x | y es true si x o y se evalúan como true. De lo contrario, el resultado es false.

El operador | siempre evalúa ambos operandos. Cuando el operando izquierdo se evalúa como true, el resultado de la operación es true independientemente del valor del operando derecho. Sin embargo, incluso después, se evalúa el operando derecho.

En el ejemplo siguiente, el operando derecho del operador | es una llamada de método, que se realiza independientemente del valor del operando izquierdo:

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

El operador ||OR lógico condicional también calcula el OR lógico de sus operandos, pero no evalúa el operando derecho si el operando izquierdo se evalúa como true.

En el caso de los operandos de los tipos numéricos enteros, el operador | calcula el OR lógico bit a bit de sus operandos.

Operador AND lógico condicional &&

El operador AND lógico condicional &&, también denominado operador AND lógico "de cortocircuito", calcula el operador AND lógico de sus operandos. El resultado de x && y es true si x y y se evalúan como true. De lo contrario, el resultado es false. Si x se evalúa como false, y no se evalúa.

En el ejemplo siguiente, el operando derecho del operador && es una llamada de método, que no se realiza si el operando izquierdo se evalúa 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

El operador& LÓGICO AND también calcula el AND lógico de sus operandos, pero siempre evalúa ambos operandos.

Operador OR lógico condicional ||

El operador OR lógico condicional ||, también denominado operador OR lógico "de cortocircuito", calcula el operador OR lógico de sus operandos. El resultado de x || y es true si x o y se evalúan como true. De lo contrario, el resultado es false. Si x se evalúa como true, y no se evalúa.

En el ejemplo siguiente, el operando derecho del operador || es una llamada de método, que no se realiza si el operando izquierdo se evalúa 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

El operador OR lógico| también calcula el operador OR lógico de sus operandos, pero siempre evalúa ambos operandos.

Operadores lógicos booleanos que aceptan valores NULL

En bool? el caso de los operandos, los & operadores (AND lógicos) y | (OR lógicos) admiten lógica de tres valores como se indica a continuación:

• El & operador solo devuelve true si ambos operandos se evalúan como true. Si o xy se evalúa como false, x & y devuelve false (incluso si otro operando se evalúa como null). De lo contrario, el resultado de x & y es null.

• El operador | produce false solo si sus dos operandos se evalúan como false. Si x o y se evalúan como true, x | y produce true (aunque otro operando se evalúe como null). De lo contrario, el resultado de x | y es null.

En la tabla siguiente se presenta esta semántica:

x	y	x e y	x | y
cierto	cierto	cierto	cierto
cierto	falso	falso	cierto
cierto	nulo	nulo	cierto
falso	cierto	falso	cierto
falso	falso	falso	falso
falso	nulo	falso	nulo
nulo	cierto	nulo	cierto
nulo	falso	falso	nulo
nulo	nulo	nulo	nulo

El comportamiento de esos operadores difiere del comportamiento típico del operador con tipos de valor que aceptan valores NULL. Normalmente, un operador definido para operandos de un tipo de valor también se puede usar con operandos del tipo de valor que acepta valores NULL correspondiente. Este tipo de operador genera null si alguno de sus operandos se evalúa como null. Sin embargo, los operadores & y | pueden generar un valor no NULL incluso si uno de los operandos es null. Para más información sobre el comportamiento de los operadores con tipos de valor que aceptan valores NULL, consulte la sección Operadores de elevación del artículo Tipos de valor que aceptan valores NULL.

También puede usar los operadores ! y ^ con los operandos bool?, como se muestra en el ejemplo siguiente:

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

Los operadores lógicos condicionales && y || no admiten los operandos bool?.

Asignación compuesta

Para un operador binario op, una expresión de asignación compuesta con el formato

x op= y

Es equivalente a

x = x op y

Excepto que x solo se evalúe una vez.

Los operadores &, | y ^ admiten la asignación compuesta, como se muestra en el ejemplo siguiente:

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

Los operadores lógicos condicionales && y || no admiten la asignación compuesta.

Prioridad de operadores

En la lista siguiente se ordenan los operadores lógicos desde la prioridad más alta a la más baja:

• Operador de negación lógico !
• Operador AND lógico &
• Operador OR exclusivo lógico ^
• Operador OR lógico |
• Operador AND lógico condicional &&
• Operador OR lógico condicional ||

Use los paréntesis, (), para cambiar el orden de evaluación impuesto por la prioridad de los operadores:

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 obtener la lista completa de los operadores de C# ordenados por nivel de prioridad, vea la sección Prioridad de operadores del artículo Operadores de C#.

Posibilidad de sobrecarga del operador

Un tipo definido por el usuario puede sobrecargar los operadores !, &, | y ^. Cuando se sobrecarga un operador binario, también se sobrecarga de forma implícita el operador de asignación compuesta correspondiente. A partir de C# 14, un tipo definido por el usuario puede sobrecargar explícitamente los operadores de asignación compuesta para proporcionar una implementación más eficaz. Normalmente, un tipo sobrecarga estos operadores porque el valor se puede actualizar en su lugar, en lugar de asignar una nueva instancia para contener el resultado de la operación binaria. Si un tipo no proporciona una sobrecarga explícita, el compilador genera la sobrecarga implícita.

Un tipo definido por el usuario no puede sobrecargar los operadores lógicos condicionales && y ||. Sin embargo, si un tipo definido por el usuario sobrecarga los operadores true y false y el operador & o | de cierta manera, la operación && o ||, respectivamente, se puede evaluar para los operandos de ese tipo. Para obtener más información, vea la sección Operadores lógicos condicionales definidos por el usuario de la Especificación del lenguaje C#.

Especificación del lenguaje C#

Para más información, vea las secciones siguientes de la Especificación del lenguaje C#:

• Operador de negación lógico
• Operadores lógicos
• Operadores lógicos condicionales
• Asignación compuesta
• Asignación compuesta definida por el usuario

Consulte también

• Operadores y expresiones de C#
• Operadores de desplazamiento y bit a bit