Is relying on && short-circuiting safe in .NET?
C#.NetOperatorsLogical OperatorsShort CircuitingC# Problem Overview
Assume myObj is null. Is it safe to write this?
if(myObj != null && myObj.SomeString != null)
I know some languages won't execute the second expression because the && evaluates to false before the second part is executed.
C# Solutions
Solution 1 - C#
Yes. In C# &&
and ||
are short-circuiting and thus evaluates the right side only if the left side doesn't already determine the result. The operators &
and |
on the other hand don't short-circuit and always evaluate both sides.
The spec says:
> The &&
and ||
operators are called the conditional logical operators. They are also called the “shortcircuiting” logical operators.
> ...
> The operation x && y
corresponds to the operation x & y
, except that y
is evaluated only if x
is true
> ...
> The operation x && y
is evaluated as (bool)x ? (bool)y : false
. In other words, x
is first evaluated and converted to type bool
. Then, if x
is true
, y
is evaluated and converted to type bool
, and this becomes the result of the operation. Otherwise, the result of the operation is false
.
(C# Language Specification Version 4.0 - 7.12 Conditional logical operators)
One interesting property of &&
and ||
is that they are short circuiting even if they don't operate on bools, but types where the user overloaded the operators &
or |
together with the true
and false
operator.
> The operation x && y
is evaluated as T.false((T)x) ? (T)x : T.&((T)x, y)
, where
T.false((T)x)
is an invocation of the operator false
declared in T
, and T.&((T)x
, y) is an invocation of the selected operator &
. In addition, the value (T)x shall only be evaluated once.
> In other words, x
is first evaluated and converted to type T
and operator false
is invoked on the result to determine if x
is definitely false
.
Then, if x
is definitely false
, the result of the operation is the value previously computed for x
converted to type T
.
Otherwise, y
is evaluated, and the selected operator &
is invoked on the value previously computed for x
converted to type T
and the value computed for y
to produce the result of the operation.
(C# Language Specification Version 4.0 - 7.12.2 User-defined conditional logical operators)
Solution 2 - C#
Yes, C# uses logical short-circuiting.
Note that although C# (and some other .NET languages) behave this way, it is a property of the language, not the CLR.
Solution 3 - C#
I know I'm late to the party, but in C# 6.0 you can do this too:
if(myObj?.SomeString != null)
Which is the same thing as above.
Solution 4 - C#
Your code is safe - && and || are both short-circuited. You can use non-short-circuited operators & or |, which evaluate both ends, but I really don't see that in much production code.
Solution 5 - C#
sure, it's safe on C#, if the first operand is false then the second is never evaluated.
Solution 6 - C#
It is perfectly safe. C# is one of those languages.
Solution 7 - C#
Yes, C# and most languages compute the if sentences from left to right.
VB6 by the way will compute the whole thing, and throw an exception if it's null...
Solution 8 - C#
an example is
if(strString != null && strString.Length > 0)
This line would cause a null exception if both sides executed.
Interesting side note. The above example is quite a bit faster than the IsNullorEmpty method.
Solution 9 - C#
In C#, &&
and ||
are short-circuited, meaning that the first condition is evaluated and the rest is ignored if the answer is determined.
In VB.NET, AndAlso
and OrElse
are also short-circuited.
In javaScript, &&
and ||
are short-circuited too.
I mention VB.NET to show that the ugly red-headed step-child of .net also has cool stuff too, sometimes.
I mention javaScript, because if you are doing web development then you probably might also use javaScript.