¿Hay un momento en que && (AndAlso) no importa lo largo y (Y)

Question

Si estoy evaluando dos variables y no dos llamadas a métodos más da tiempo utilizo "& &" o "&"

//some logic that sets bool values 

boolean X = true; 
boolean Y = true; 

if (X & Y){ 
    // perform some operation 
} 

if (X && Y){ 
    // perform some operation 
} 

Además, un libro que estoy usando para C# 3.0/.NET 3.5 solo hace referencia al operador & &, ¿el operador & está desapareciendo?

Answer 1

Como se ha observado, & es el operador AND bit a bit. La matemática binaria en bruto parece ser cada vez menos común con el tiempo, con un número cada vez mayor de desarrolladores que no entienden realmente la aritmética bit a bit. Lo cual puede ser un dolor a veces.

Sin embargo, hay una gran cantidad de tareas que se resuelven mejor con tales, en particular, todo lo que ve los datos como indicadores. El operador & es 100% necesario y no va a ninguna parte; simplemente no se usa con la misma frecuencia que el operador booleano de cortocircuito &&.

Por ejemplo:

[Flags] 
enum SomeEnum { // formatted for space... 
    None = 0, Foo = 1, Bar = 2 // 4, 8, 16, 32, ... 
} 
static void Main() { 
    SomeEnum value = GetFlags(); 
    bool hasFoo = (value & SomeEnum.Foo) != 0; 
} 
static SomeEnum GetFlags() { ... } 

Answer 2

Siempre use & & si está realizando una prueba de lógica verdadera/falsa. Un solo & realiza un bit '' y ''. En algunos casos funciona como una prueba lógica, pero no se garantiza que funcione para todos los casos de lógica. El uso más común de un solo & es cuando se aplica una máscara de bits.

Ejemplos (& &):

true && true == true 

Ejemplo (&):

00101001 & 00100001 = 00100001 

Answer 3

& es un operador de bits mientras & & es el operador AND. Dos operaciones completamente diferentes.

int a = 1; 
int b = 2; 
assert (a & b == 0) 
assert (a && b == true) 

EDITAR: Ooops ... este ejemplo no funciona en C#. Debería en C++. Esperemos que ilustre la intención y la diferencia entre los dos operadores.

Answer 4

Si usa un solo & (Y) se evalúa la segunda parte de la expresión. Esto podría ser malo si la segunda parte depende de que la primera parte sea verdadera. Por lo general, siempre use & & ya que la segunda parte no se evalúa si la primera parte es falsa.

Lógicamente, el único & realiza una operación bit a bit como han dicho otros, que sigue siendo válido para la comparación/evaluación booleana. Realmente, el único momento en que se debe usar un solo & (o |) (o una evaluación booleana) es si la segunda evaluación siempre debe ejecutarse (si se trata de una función de llamada/modificador). Esta es una mala práctica y probablemente por qué el libro no lo menciona.

Solo & son útiles con indicadores de posición y máscaras de bits.

A continuación se producirá una excepción de obj es nulo:

bool b = obj != null & obj.IsActive 

Pero esto va a funcionar:

bool b = obj != null && obj.IsActive 

Esto es malo:

bool b = obj.IsActive && obj.SetActive(false); 
bool b = obj.IsActive & obj.SetActive(false); 

El operador & está aquí quedarse.