Why does ReSharper invert IFs for C# code? Does it give better performance (even slightly)?

Consider the following code sample:

private void AddEnvelope(MailMessage mail)
{
    if (this.CopyEnvelope)
    {
      开发者_JAVA技巧  // Perform a few operations
    }
}

vs

private void AddEnvelope(MailMessage mail)
{
    if (!this.CopyEnvelope) return;
    // Perform a few operations
}

Will the bottom code execute any faster? Why would ReSharper make this recommendation?

Update

Having thought about this question the answer might seem obvious to some. But lots of us developers were never in the habit of nesting zounds of if statements in the first place...

It doesn't matter. Stop agonizing over performance issues that don't exist - use a profiler to identify areas in your code that DO exhibit issues, and fix them. Proactive optimization - before you know that there is a problem - is by definition a waste of time.

Updated Answer:

It's a code maintainability suggestion. Easier to read than nesting the rest of the code in an IF statement. Examples/discussion of this can be seen at the following links:

• Flattening Arrow Code
• Replace Nested Conditional With Guard Clauses
• Code Contracts section "Legacy Requires Statements"

Original Answer:

It will actually run (very negligibly) slower from having to perform a NOT operation.

So much in fact, some people actually consider that prettier way to code as it avoids an extra level of indentation for the bulk of the code.

It's a refactor of a conditional that encompasses the entire method contents to a Guard Clause. It has nothing to do with optimization.

I like the comments about optimizing things like this, to add a little more to it...

The only time I can think of that it makes sense to optimize your if statements is when you have the results of TWO or more longish running methods that need to be combined to determine to do something else. You would only want to execute the second operation if the first operation yielded results that would pass the condition. Putting the one that is most likely to return false first will generally be a smarter choice. This is because if it is false, the second one will not be evaluated at all. Again, only worth worrying about if the operations are significant and you can predict which is more likely to pass or fail. Invert this for OR... if true, it will only evaluate the first, and so optimize that way. i.e.

if (ThisOneUsuallyPasses() && ThisOneUsuallyFails())

isn't so good as

if (ThisOneUsuallyFails() && ThisOneUsuallyPasses())

because it's only on the odd case that the first one actually works that you have to look at the second. There's some other flavors of this you can derive, but I think you should get the point.

Better to worry about how you use strings, collections, index your database, and allocate objects than spend a lot of time worrying about single condition if statements if you are worrying about perf.

In general, what the bottom code you give will do is give you an opportunity to avoid a huge block of code inside an if statement which can lead to silly typo driven errors. Old school thinking was that you should only have one point that you return from a method to avoid a different breed of coder error. Current thinking (at least by some of the tool vendors such as jetbrains resharper, etc) seems to be that wrapping the least amount of code inside of conditional statements is better. Anything more than that would be subjective so I'll leave it at that.

This kind of "Optimizations" are not worth the time spent on refactoring your code, because all modern compilers does already enough small optimizations that they make this kind of tips trivial. As mentioned above Performance Optimization is done through profilers to calculate how your system is performing and the potential bottlenecks before applying the performance fix, and then after the performance fix to see if your fix is any good.

Required reading: Cyclomatic_complexity

Cyclomatic Complexity is a quantitative measure of the number of linearly independent paths through a program's source code

Which means, every time you branch using and if statement you increase the Cyclomatic Complexity by 1.

To test each linearly independent path through the program; in this case, the number of test cases will equal the cyclomatic complexity of the program.

Which means, if you want to test your code completely, for each if statement you would have to introduce a new test case.

So, by introducing more if statements the complexity of your code increases, as does the number of test cases required to test it.

By removing if statements, your code complexity decreases as does the number of test cases required to test.