?: Operator Vs. If Statement Performance

Question

I've been trying to optimize my code to make it a little more concise and readable and was hoping I wasn't causing poorer performance from doing it. I think my changes might have slowed down my application, but it might just be in my head. Is there any performance difference between:

Command.Parameters["@EMAIL"].Value = email ?? String.Empty;

and

Command.Parameters["@EMAIL"].Value = (email == null) ? String.Empty: email;

and

if (email == null)
{
    Command.Parameters["@EMAIL"].Value = String.Empty
}
else
{
    Command.Parameters["@EMAIL"].Value = email
}

My preference for readability would be the null coalescing operator, I just didn't want it to affect performance.

Solution 1

IMHO, optimize for readability and understanding - any run-time performance gains will likely be minimal compared to the time it takes you in the real-world when you come back to this code in a couple months and try to understand what the heck you were doing in the first place.

Solution 2

You are trying to micro-optimize here, and that's generally a big no-no. Unless you have performance analytics which are showing you that this is an issue, it's not even worth changing.

For general use, the correct answer is whatever is easier to maintain.

For the hell of it though, the IL for the null coalescing operator is:

L_0001: ldsfld string ConsoleApplication2.Program::myString
L_0006: dup 
L_0007: brtrue.s L_000f
L_0009: pop 
L_000a: ldsfld string [mscorlib]System.String::Empty
L_000f: stloc.0 

And the IL for the switch is:

L_0001: ldsfld string ConsoleApplication2.Program::myString
L_0006: brfalse.s L_000f
L_0008: ldsfld string ConsoleApplication2.Program::myString
L_000d: br.s L_0014
L_000f: ldsfld string [mscorlib]System.String::Empty
L_0014: stloc.0 

For the null coalescing operator, if the value is null, then six of the statements are executed, whereas with the switch, four operations are performed.

In the case of a not null value, the null coalescing operator performs four operations versus five operations.

Of course, this assumes that all IL operations take the same amount of time, which is not the case.

Anyways, hopefully you can see how optimizing on this micro scale can start to diminish returns pretty quickly.

That being said, in the end, for most cases whatever is the easiest to read and maintain in this case is the right answer.

If you find you are doing this on a scale where it proves to be inefficient (and those cases are few and far between), then you should measure to see which has a better performance and then make that specific optimization.

Solution 3

I think my changes might have slowed down my application, but it might just be in my head.

Unless you are actually measuring performance, it's all in your head and idle speculation.

(Not to pick on you in particular, but it is so disappointing to see question after question about performance micro-optimizations (as well as many of the answers) that do not contain the word "measure".)

Solution 4

I suspect there won't be any performance difference.

Next to that, I wonder why you would have any concerns of favoring one statement over the other in this case ? I mean: the performance impact (if there should be any), would be minimal. IMHO, this would be a kind of micro-optimization, and it shouldn't be worth the effort.
I would choose the statement that is most readable, most clear, and not worry about performance since it would be of minimal influence (in this case).

Solution 5

Almost no significant performance difference in this case.

When the performance difference is negligible, it is all about readable code.

View more solutions