Operadores lógicos booleanos (referencia de C#)Boolean logical operators (C# reference)

Los operandos siguientes realizan operaciones lógicas con los operandos bool:The following operators perform logical operations with the bool operands:

En el caso de los operandos de tipo entero, los operadores &, | y ^ realizan operaciones lógicas bit a bit.For the operands of the integral types, the &, |, and ^ operators perform bitwise logical operations. Para obtener más información, vea Operadores de desplazamiento y bit a bit.For more information, see Bitwise and shift operators.

Operador de negación lógico !Logical negation operator !

El operador ! de prefijo unario calcula la negación lógica de su operando.The unary prefix ! operator computes logical negation of its operand. Es decir, genera true, si el operando se evalúa como false, y false, si el operando se evalúa como 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 partir de C# 8.0, el operador ! de postfijo unario es un operador que permite un valor NULL.Starting with C# 8.0, the unary postfix ! operator is a null-forgiving operator.

Operador AND lógico &Logical AND operator &

El operador & calcula el operador AND lógico de sus operandos.The & operator computes the logical AND of its operands. El resultado de x & y es true si x y y se evalúan como true.The result of x & y is true if both x and y evaluate to true. De lo contrario, el resultado es false.Otherwise, the result is false.

El operador & evalúa ambos operandos, incluso aunque el izquierdo se evalúe como false, de modo que el resultado debe ser false con independencia del valor del operando derecho.The & operator evaluates both operands even if the left-hand operand evaluates to false, so that the result must be false regardless of the value of the right-hand operand.

En el ejemplo siguiente, el operando derecho del operador & es una llamada de método, que se realiza independientemente del valor del operando izquierdo: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

El operador AND lógico condicional && también calcula el operador AND lógico de sus operandos, pero no evalúa el operando derecho si el izquierdo se evalúa como 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.

En el caso de los operandos de tipo entero, el operador & calcula el AND lógico bit a bit de sus operandos.For the operands of the integral types, the & operator computes the bitwise logical AND of its operands. El operador & unario es el operador address-of.The unary & operator is the address-of operator.

Operador IR exclusivo lógico ^Logical exclusive OR operator ^

El operador ^ calcula el operador OR exclusivo lógica, también conocido como el operador XOR lógico, de sus operandos.The ^ operator computes the logical exclusive OR, also known as the logical XOR, of its operands. El resultado de x ^ y es true si x se evalúa como true y y se evalúa como false o x se evalúa como false y y se evalúa como 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. De lo contrario, el resultado es false.Otherwise, the result is false. Es decir, para los operandos bool, el operador ^ calcula el mismo resultado como el operador de desigualdad !=.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

En el caso de los operandos de tipo entero, el operador ^ calcula el OR exclusivo lógico bit a bit de sus operandos.For the operands of the integral types, the ^ operator computes the bitwise logical exclusive OR of its operands.

Operador lógico OR |Logical OR operator |

El operador | calcula el operador OR lógico de sus operandos.The | operator computes the logical OR of its operands. El resultado de x | y es true si x o y se evalúan como true.The result of x | y is true if either x or y evaluates to true. De lo contrario, el resultado es false.Otherwise, the result is false.

El operador | evalúa ambos operandos, incluso aunque el izquierdo se evalúe como true, de modo que el resultado debe ser true con independencia del valor del operando derecho.The | operator evaluates both operands even if the left-hand operand evaluates to true, so that the result must be true regardless of the value of the right-hand operand.

En el ejemplo siguiente, el operando derecho del operador | es una llamada de método, que se realiza independientemente del valor del operando izquierdo: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

El operador OR lógico condicional || también calcula el operador OR lógico de sus operandos, pero no evalúa el operando derecho si el izquierdo se evalúa como 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.

En el caso de los operandos de tipo entero, el operador | calcula el OR lógico bit a bit de sus operandos.For the operands of the integral types, the | operator computes the bitwise logical OR of its operands.

Operador AND lógico condicional &&Conditional logical AND operator &&

El operador AND lógico condicional &&, también denominado operador AND lógico "de cortocircuito", calcula el operador AND lógico de sus operandos.The conditional logical AND operator &&, also known as the "short-circuiting" logical AND operator, computes the logical AND of its operands. El resultado de x && y es true si x y y se evalúan como true.The result of x && y is true if both x and y evaluate to true. De lo contrario, el resultado es false.Otherwise, the result is false. Si x se evalúa como false, y no se evalúa.If x evaluates to false, y is not evaluated.

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: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

El operador AND lógico & también calcula el operador AND lógico de sus operandos, pero siempre evalúa ambos operandos.The logical AND operator & also computes the logical AND of its operands, but always evaluates both operands.

Operador OR lógico condicional ||Conditional logical OR operator ||

El operador OR lógico condicional ||, también denominado operador OR lógico "de cortocircuito", calcula el operador OR lógico de sus operandos.The conditional logical OR operator ||, also known as the "short-circuiting" logical OR operator, computes the logical OR of its operands. El resultado de x || y es true si x o y se evalúan como true.The result of x || y is true if either x or y evaluates to true. De lo contrario, el resultado es false.Otherwise, the result is false. Si x se evalúa como true, y no se evalúa.If x evaluates to true, y is not evaluated.

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: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

El operador OR lógico | también calcula el operador OR lógico de sus operandos, pero siempre evalúa ambos operandos.The logical OR operator | also computes the logical OR of its operands, but always evaluates both operands.

Operadores lógicos booleanos que aceptan valores NULLNullable Boolean logical operators

En el caso de los operandos bool?, los operadores & y | admiten la lógica de tres valores.For the bool? operands, the & and | operators support the three-valued logic. La semántica de estos operadores se define en la tabla siguiente:The semantics of these operators is defined by the following table:

xx yy x e yx&y x|yx|y
truetrue truetrue truetrue truetrue
truetrue Falsefalse falsefalse truetrue
truetrue nulonull nulonull truetrue
Falsefalse truetrue Falsefalse truetrue
Falsefalse Falsefalse Falsefalse Falsefalse
Falsefalse nulonull Falsefalse nulonull
nulonull truetrue nulonull truetrue
nulonull Falsefalse Falsefalse nulonull
nulonull nulonull nulonull nulonull

El comportamiento de esos operadores difiere del comportamiento típico del operador con tipos de valor que aceptan valores NULL.The behavior of those operators differs from the typical operator behavior with nullable value types. Por lo general, un operador que se define para los operandos de un tipo de valor también se puede usar con los operandos del tipo de valor que acepta valores NULL correspondientes.Typically, an operator which is defined for operands of a value type can be also used with operands of the corresponding nullable value type. Este tipo de operador genera null si alguno de sus operandos es null.Such an operator produces null if any of its operands is null. Sin embargo, los operadores & y | pueden generar un valor no NULL incluso si uno de los operandos es null.However, the & and | operators can produce non-null even if one of the operands is null. Para más información sobre el comportamiento de los operandos con tipos de valor que aceptan valores NULL, consulte la sección Operadores del artículo Uso de tipos de valor que admiten un valor NULL.For more information about the operator behavior with nullable value types, see the Operators section of the Using nullable value types article.

También puede usar los operadores ! y ^ con los operandos bool?, como se muestra en el ejemplo siguiente:You can also use the ! and ^ operators with the 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());

Los operadores lógicos condicionales && y || no admiten los operandos bool?.The conditional logical operators && and || don't support the bool? operands.

Asignación compuestaCompound assignment

Para un operador binario op, una expresión de asignación compuesta con el formatoFor a binary operator op, a compound assignment expression of the form

x op= y

es equivalente ais equivalent to

x = x op y

salvo que x solo se evalúa una vez.except that x is only evaluated once.

Los operadores &, | y ^ admiten la asignación compuesta, como se muestra en el ejemplo siguiente: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

Los operadores lógicos condicionales && y || no admiten la asignación compuesta.The conditional logical operators && and || don't support compound assignment.

Prioridad de operadoresOperator precedence

En la lista siguiente se ordenan los operadores lógicos desde la prioridad más alta a la más baja:The following list orders logical operators starting from the highest precedence to the lowest:

  • Operador de negación lógico !Logical negation operator !
  • Operador AND lógico &Logical AND operator &
  • Operador OR exclusivo lógico ^Logical exclusive OR operator ^
  • Operador OR lógico |Logical OR operator |
  • Operador AND lógico condicional &&Conditional logical AND operator &&
  • Operador OR lógico condicional ||Conditional logical OR operator ||

Use los paréntesis, (), para cambiar el orden de evaluación impuesto por la prioridad de los operadores: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

Para obtener la lista completa de los operadores de C# ordenados por nivel de prioridad, vea Operadores de C#.For the complete list of C# operators ordered by precedence level, see C# operators.

Posibilidad de sobrecarga del operadorOperator overloadability

Un tipo definido por el usuario puede sobrecargar los operadores !, &, | y ^.A user-defined type can overload the !, &, |, and ^ operators. Cuando se sobrecarga un operador binario, también se sobrecarga de forma implícita el operador de asignación compuesta correspondiente.When a binary operator is overloaded, the corresponding compound assignment operator is also implicitly overloaded. Un tipo definido por el usuario no puede sobrecargar de forma explícita un operador de asignación compuesta.A user-defined type cannot explicitly overload a compound assignment operator.

Un tipo definido por el usuario no puede sobrecargar los operadores lógicos condicionales && y ||.A user-defined type cannot overload the conditional logical operators && and ||. 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.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. 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#.For more information, see the User-defined conditional logical operators section of the C# language specification.

Especificación del lenguaje C#C# language specification

Para más información, vea las secciones siguientes de la Especificación del lenguaje C#:For more information, see the following sections of the C# language specification:

Vea tambiénSee also