Short circuit on |= and &= assignment operators in C#

Question

I know that || and && are defined as short-circuit operators in C#, and such behaviour is guaranteed by the language specification, but do |= and &= short-circuit too?

For example:

private bool IsEven(int n)
{
    return n % 2 == 0;
}

private void Main()
{
    var numbers = new int[] { 2, 4, 6, 8, 9, 10, 14, 16, 17, 18, 20 };

    bool allEven = true;
    bool anyOdd = false;

    for (int i = 0; i < numbers.Length; i++)
    {
        allEven &= IsEven(numbers[i]);
        anyOdd |= !IsEven(numbers[i]);
    }
}

When the 9 entry is hit, allEven becomes false, meaning that all subsequent entries are irrelevant - the value of allEven is guaranteed to be false for all future calls to that expression. The same goes for anyOdd, which is set to true when it sees 9, and will remain true for all subsequent calls to that expression.

So, do &= and |= shortcut, or is IsEven guaranteed to be called on every iteration? Is there any defined behaviour in the language specification for this case? Are there any corner-cases where such short circuiting would be problematic?

Utgardloki

Answer 1

The C# specification guarantees that both sides are evaluated exactly once from left-to-right and that no short-circuiting occurs.

5.3.3.21 General rules for expressions with embedded expressions

The following rules apply to these kinds of expressions: parenthesized expressions (§7.6.3), element access expressions (§7.6.6), base access expressions with indexing (§7.6.8), increment and decrement expressions (§7.6.9, §7.7.5), cast expressions (§7.7.6), unary +, -, ~, * expressions, binary +, -, *, /, %, <<, >>, <, <=, >, >=, ==, !=, is, as, &, |, ^ expressions (§7.8, §7.9, §7.10, §7.11), compound assignment expressions (§7.17.2), checked and unchecked expressions (§7.6.12), plus array and delegate creation expressions (§7.6.10).

Each of these expressions has one or more sub-expressions that are unconditionally evaluated in a fixed order.

The C# specification for compound operators says:

7.17.2 Compound assignment

...

An operation of the form x op= y is processed by applying binary operator overload resolution (§7.3.4) as if the operation was written x op y. Then,

• If the return type of the selected operator is implicitly convertible to the type of x, the operation is evaluated as x = x op y, except that x is evaluated only once.

• Otherwise, if the selected operator is a predefined operator, if the return type of the selected operator is explicitly convertible to the type of x, and if y is implicitly convertible to the type of x or the operator is a shift operator, then the operation is evaluated as x = (T)(x op y), where T is the type of x, except that x is evaluated only once.

...

In your case op is & or |. The short circuiting behavior mirrors that of &/| and not &&/||.

---

Note that this only refers to behavior visible in a single threaded scenario. So if the right hand side has no side-effects that are observable in such a scenario, the compiler or JITter is still free to omit the evaluation.

In your example the compiler is free to terminate the loop once it knows the result, since there are no such side-effects. But it's not required to do so.

In particular timing does not count as such a side-effect, and you thus can't rely on your code having constant runtime. This can be problematic in a security context, since it can introduce a timing side-channel.

Twickenham

Excellent answer. I'll remember not to rely on it calling on every iteration. Great point about side channel attacks too. – Utgardloki

Answer 2

but do |= and &= short-circuit too?

No. &= and |= are the equivalents of the operations & and |, not of the short-circuited logical operators.

Allow

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 msdn.microsoft.com/en-us/library/sbf85k1c(v=vs.80).aspx – Forlorn

@Roman I’m not sure in relation to what you’ve posted that. Both Guffa and I are aware of this … – Allow

Actually, it's more for other reader like me, not for you, I see that both of you aware of that. – Forlorn

Answer 3

No, the &= and |= operators are not doing short-circuit evaluation.

They are pseudo-operators, which the compiler converts into use of the & and | operators.

This code:

allEven &= IsEven(numbers[i]);

is exactly equivalent to:

allEven = allEven & IsEven(numbers[i]);

If you want the short circuited check, then you have to write it out using the short circuiting versions of the operators:

allEven = allEven && IsEven(numbers[i]);

There is no &&= pseudo operator, but the code above is exactly what the compiler would do if there was one.

Radarscope

Are the pseudo-operators and their behaviours defined in the language spec, or are they bolt-on syntactic sugar provided by the IDE / compiler? – Utgardloki

@Polynomial: It's covered in the chapter "7.17.2 Compound assignment" in the language specification. – Radarscope