Cuál es la diferencia entre & y operadores & en C#

Question

Estoy tratando de entender la diferencia entre & y & & operadores en C#. Busqué en Internet sin mucho éxito. ¿Alguien puede explicar con un ejemplo?

Answer 1

El primero es bitwise and el segundo es boolean and.

Answer 2

& es una operador bit a bit y & & es un lógico operador que se aplica a bool operandos.

Answer 3

& es el operador AND bit a bit. Para operandos de tipos enteros, calculará el AND a nivel de bit de los operandos y el resultado será un tipo entero. Para operandos booleanos, calculará el lógico y de operandos. && es el operador AND lógico y no funciona en tipos enteros. Para los tipos booleanos, donde ambos se pueden aplicar, la diferencia está en la propiedad de "cortocircuito" de &&. Si el primer operando de && se evalúa como false, el segundo no se evalúa en absoluto. Este no es el caso para &:

bool f() { 
    Console.WriteLine("f called"); 
    return false; 
} 
bool g() { 
    Console.WriteLine("g called"); 
    return false; 
} 
static void Main() { 
    bool result = f() && g(); // prints "f called" 
    Console.WriteLine("------"); 
    result = f() & g(); // prints "f called" and "g called" 
} 

|| es similar a && en esta propiedad; solo evaluará el segundo operando si el primero lo evalúa como falso.

Por supuesto, los tipos definidos por el usuario pueden sobrecargar estos operadores haciéndolos hacer lo que quieran.

Answer 4

Hai Friend, El operador & & (operador lógico) se utiliza en sentencias condicionales. por ejemplo

if(firstName == 'Tilsan' && lastName == 'Fighter') 
{ 
     Response.Write("Welcome Tilsan The Fighter!"); 
} 

la instrucción Response.Write se ejecutará sólo si ambas variables primerNombre y combinar lastName a su condición.

Mientras & (bit a bit del operador) del operador se utiliza para binarios y operaciones, es decir, si escribimos:

bool a, b, c; 

a = true; 
b = false; 

c = a & b; 

Response.Write(c); // 'False' will be written to the web page 

Aquí primera binario y la operación se llevará a cabo en las variables a y b, y el valor resultante ser almacenado en la variable c.

Answer 5

Fácil manera de mirar es lógico & evaluará ambos lados de la & sin tener en cuenta si el lado izquierdo es falsa, mientras que el cortocircuito & & sólo se evaluará el lado derecho si la izquierda es cierto.

d=0; 
n=10; 

// this throws divide by 0 exception because it evaluates the 
//  mod even though "d != 0" is false 
if ((d != 0) & (n % d) == 0) 
    Console.Writeline(d + " is a factor of " + n); 

// This will not evaluate the mod. 
if ((d != 0) && (n % d) == 0) 
    Console.Writeline(d + " is a factor of " + n); 

Answer 6

recomiendan enérgicamente este artículo de Dotnet Mob: http://dotnetmob.com/csharp-article/short-circuit-evaluation-in-c/

- & & es de cortocircuito operador lógico

Por y operaciones de si alguno de los operandos evaluaron para la expresión a continuación, total de falsa evaluado a falso, por lo que no es necesario evaluar las expresiones restantes, de forma similar en la operación OR si se puede omitir cualquiera de los operandos evaluados en la evaluación verdadera y luego restante

- & operador se puede utilizar como operador unario o binario. es decir, unario & se puede usar para obtener la dirección de su operando en un contexto inseguro.

Answer 7

Según - C# 4.0 The Complete Reference por Herbert Schildt

& - Lógico AND
| - operador lógico OR

& & - Puente de conexión del operador Y
|| - cortocircuito o del operador

Un ejemplo sencillo puede ayudar a entender los fenómenos

using System; 

class SCops { 
    static void Main() { 
     int n, d; 
     n = 10; 
     d = 2; 

     if(d != 0 && (n % d) == 0) 
      Console.WriteLine(d + " is a factor of " + n); 
     d = 0; // now, set d to zero 

     // Since d is zero, the second operand is not evaluated. 
     if(d != 0 && (n % d) == 0) 
      Console.WriteLine(d + " is a factor of " + n); 
     // Now, try the same thing without the short-circuit operator. 
     // This will cause a divide-by-zero error. 
     if(d != 0 & (n % d) == 0) 
      Console.WriteLine(d + " is a factor of " + n); 
    } 
} 

Aquí los & operador comprueba cada uno y cada operando y & & comprueba sólo el primer operando.

Como puede observar para las operaciones 'AND', cualquier operando que sea falso evaluará toda la expresión como falsa, independientemente de cualquier otro valor de operandos en la expresión. Esta forma de cortocircuito ayuda a evaluar la primera parte y es lo suficientemente inteligente como para saber si la segunda parte será necesaria.

Ejecutando el programa arrojará un error de división por cero para la última condición if donde se verifican los operandos para el operador & y no se realiza ninguna excepción para abordar el hecho de que 'd' puede ser 0 en cualquier punto de tiempo.

El mismo caso se aplica a '|' Cª#.

Esto es ligeramente diferente de C o C++ donde '&' y '|' eran operadores bit a bit AND y OR. Sin embargo, C# también aplica la naturaleza bit a bit de & y | solo para variables int.