What is the difference between & and && operators in C#

Question

I am trying to understand the difference between & and &&operators in C#. I searched on the internet without success. Can somebody plea

Answer 1

The first one is bitwise and the second one is boolean and.

Answer 2

According to - C# 4.0 The Complete Reference by Herbert Schildt

& - Logical AND Operator
| - Logical OR Operator

&& - Short Circuited AND Operator
|| - Short Circuited OR Operator

A simple example can help understand the phenomena

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

Here the & operator checks each and every operand and && checks only the first operand.

As you might notice for 'AND' operations any operand which is false will evaluate the whole expression to false irrespective of any other operands value in the expression. This short circuited form helps evaluate the first part and is smart enough to know if the second part will be necessary.

Running the program will throw a divide-by-zero error for the last if condition where both the operands are checked for & operator and no exception handling is done to tackle the fact that 'd' can be 0 at any point of time.

The same case applies to '|' in C#.

This is slightly different than C or C++ where '&' and '|' were bitwise AND and OR operators. However C# also applies the bitwise nature of & and | for int variables only.

Answer 3

& is the bitwise AND operator. For operands of integer types, it'll calculate the bitwise-AND of the operands and the result will be an integer type. For boolean operands, it'll compute the logical-and of operands. && is the logical AND operator and doesn't work on integer types. For boolean types, where both of them can be applied, the difference is in the "short-circuiting" property of &&. If the first operand of && evaluates to false, the second is not evaluated at all. This is not the case for &:

 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"
 }

|| is similar to && in this property; it'll only evaluate the second operand if the first evaluates to false.

Of course, user defined types can overload these operators making them do anything they want.