¿Por qué uno usaría el operador | = en un valor booleano en C#?

Question

Ejemplo:

Encontramos que este es un código escrito por un proveedor y estamos tratando de descubrir por qué lo harían.

bool tmp = false; 

if (somecase) 
    tmp = true; 

if (someOtherCase) 
    tmp |= true; 

Answer 1

Sin ninguna buena razón en absoluto. Un valor booleano |= true siempre será true. Esto es alguien tratando de ser elegante, u olvidando la lógica booleana =)

Cambie a tmp = true;.

Answer 2

El resultado final será "Si cualquiera de los casos es cierto, el resultado será verdadero". Sin embargo, no hay ninguna razón por la que deba usar el operador, ya que el || en un if funcionaría igual de bien.

Answer 3

interesante - que parece que se está haciendo el equivalente:

tmp = tmp | true; 

que siempre será establecido tmp en true.

Answer 4

Quizás uno de los literales booleanos solía ser una variable, y simplemente no pensaron cambiar el operador cuando cambiaron el operando. Obviamente, la lógica es equivalente.

Es más probable que pensaran que, en el segundo caso, quieren conservar el resultado de evaluar la primera condición "si". Por supuesto, eso es falso razonamiento.

una declaración equivalente más simple:

bool tmp = somecase | someOtherCase; 

EDITAR

Como notas pickypg, esta declaración podría ser confuso, ya que la mayoría de la gente no espera | con valores booleanos, y muchos no lo notará , o no piensa en las implicaciones de los efectos secundarios. La mejor manera de ser explícito (si de hecho hay efectos secundarios) sería la solución de minitech: simplemente cambie el |= al =.

O, si no hay efectos secundarios en la expresión someOtherCase, use la solución de Jakub Konecki: someCase || someOtherCase.

Answer 5

Esto es equivalente a

tmp = tmp | true; 

EDIT: que es igual a

tmp = true; 

estoy de acuerdo con el resto de los críticos aquí ...!

Más información here

Answer 6

foo |= true es una versión corta de foo = foo | true.

El código real puede reescribirse como

bool tmp = false; 
tmp |= someCase; 
tmp |= someOtherCase; 

O aún mejor, ya

someCase || someOtherCase 

Answer 7

Su expresión utilizando el | = operador de asignación. Check MSDN

Answer 8

Un compilador inteligente podría evitar la asignación en este caso, aunque probablemente no lo haría ya que no debería provocar un cortocircuito en una operación de bit a bit. En cualquier caso, parece una micro-optimización. En realidad, sospecho que se trata de un patrón de retención que el autor usa para usar indicadores de bits (o el/ella no comprende cómo funciona). Sería mejor como:

bool tmp = somecase || someOthercase; 

(en línea y luego el temporal si lo utiliza solamente una vez)

Tenga en cuenta que, al usar banderas, sí tiene sentido.

#define CONDITION_ONE 0x01 
#define CONDITION_TWO 0x02 

int temp = 0; 
if (somecase) { 
    temp = CONDITION_ONE; 
} 

if (someOthercase) { 
    temp |= CONDITION_TWO; 
} 

Answer 9

para Bools no tanto

embargo

para bitflags Esto puede permitir código como este:

int flags=0; 
flags|=READ; 
//flags|=UPDATE; 
foo(arg,flags); 

esto permite algunas banderas para ser comentados fácilmente (y hace las banderas usadas un poco OMI más legible)

Answer 10

Al igual que los otros operadores op = x |= y es equivalente (excepto efectos secundarios de evaluación múltiple) a x = x | y. Esta es una manera concisa de escribir if (!x) x = y; o if (y) x = true;.

Sin embargo, no tiene sentido tener constante en el lado derecho.

• x |= true se escribe más directa como x = true
• x |= false deja x sin cambios.

por qué harían esto.

Algunas posibles explicaciones son:

• Es un error tipográfico: Se referían a escribir en lugar de tmp = true;tmp |= true;, pero nunca se dieron cuenta que debido a que su programa pasó a funcionar como se espera.
• El RHS era originalmente una variable, que se reemplazó con la constante true sin cambiar el código.
• tmp era originalmente un bitfield (para el cual |= tiene más sentido), que luego se redujo a un solo bit.