What is the second meaning of a single ampersand in C#?

Question

I have used the single ampersand (&) in C# to mean "check the second conditional statement even if the first is false".

But the following seems to be a different meaning of & altogether, can anyone explain how i & 1 works in the following example?

List<int> scores = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8 };
var evenScores = scores.Where(i => i % 2 == 0);
var evenScores2 = scores.Where(i => (i & 1) == 0);

Answer 1

Here:

The unary & operator returns the address of its operand (requires unsafe context).

Binary & operators are predefined for the integral types and bool. For integral types, & computes the logical bitwise AND of its operands. For bool operands, & computes the logical AND of its operands; that is, the result is true if and only if both its operands are true.

The & operator evaluates both operators regardless of the first one's value.

Answer 2

Prior answers are true but don't address how & differs from &&, which I thought was your original question, so I'll take that.

As has been said, & is a bitwise AND. && is a logical AND. & performs an AND operation on its operands bit by bit, and in general functions exactly like + or * or any arithmetic operator. && is more complex. It compares each of its operands against zero. If the first operand is zero, it assumes the value false and short-circuits the rest of the expression, i.e. it does not evaluate any remaining operands. If the first value is non-zero, it examines the second value. If this is zero, it assumes the value of false, otherwise it assumes the value of true. In either case, it continues to evaluate the expression.

That is, there are two crucial differences between & and &&:

1. & operates bit by bit while && considers only zero and non-zero and always returns either 0 or 1. Thus 5 & 6 (binary 101 & 110) gives 4 (binary 100), while 5 && 6 gives 1 (true).

2. && "short circuits". If the first value is zero, it does not evaluate the second value. & has no such rule. This is important in several ways:

   1. If the second value has any side effects, then with & those side effects always happen, while with && they do not. So x & (y++) will always increment y, while x && (y++) will only increment y if x is not zero. This gets more important—and possibly more subtle—if the second operand is a function call.
   2. The first value may test something that determines that the second value is invalid. Like x!=NULL && x->foo==3. With &, when x is null, that could bomb with segment faults or the equivalent.
   3. Lastly, there may be important performance gains. Like, x!='A' && readTonsOfStuffFromDatabaseAndCalculateTotal(x). With &, the read would happen regardless, and perhaps be a total waste of time.

That's why we almost always use && for things that really are logical operations, and limit use of & to when we truly want a bit-wise operation. But there are times when you DON'T want the short-circuit to happen, and in that case & may be a good choice. But if you're using it to operate "logically", be very careful with operands that can have any values other than 0 or 1. 1 && 2 is true, but 1 & 2 is false.