In .NET, will empty method calls be optimized out?

Question

Title says it all, given an empty method body, will the JIT optimize out the call (I know the C# compiler won't). How would I go about finding out? What tools should I be using and where should I be looking?

Since I'm sure it'll be asked, the reason for the empty method is a preprocessor directive.

Answer 1

I do remember reading something a while ago which said that this would be the case, but possibly only in release mode. I'm not sure.

Answer 2

Have you tried decompiling your code using ILDAsm to find out?

Answer 3

No, empty methods are never optimized out. Here are a couple reasons why:

• The method could be called from a derived class, perhaps in a different assembly
• The method could be called using Reflection (even if it is marked private)

Edit: Yes, from looking at that (exellent) code project doc the JITer will eliminate calls to empty methods. But the methods themselves will still be compiled and part of your binary for the reasons I listed.

Answer 4

All things being equal, yes it should be optimized out. The JIT inlines functions where appropriate and there are few things more appropriate than empty functions :)

If you really want to be sure then change your empty method to throw an exception and print out the stack trace it contains.

Answer 5

This chap has quite a good treatment of JIT optimisations, do a search on the page for 'method is empty', it's about half way down the article -

http://www.codeproject.com/KB/dotnet/JITOptimizations.aspx

Apparently empty methods do get optimised out through inlining what is effectively no code.

@Chris: I do realise the that the methods will still be part of the binary and that these are JIT optimisations :-). On a semi-related note, Scott Hanselman had quite an interesting article on inlining in Release build call stacks:

http://www.hanselman.com/blog/ReleaseISNOTDebug64bitOptimizationsAndCMethodInliningInReleaseBuildCallStacks.aspx

HTH

Answer 6

@Jon Limjap: We already know the C# compiler doesn't optimize empty methods out. Since what you're decompiling with ildasm was generated by the C# compiler... no help there.

Answer 7

@Chris: Makes sense, but it could optimize out calls to the method. So the method would still exist, but static calls to it could be removed (or at least inlined...)

@Jon: That just tells me the language compiler doesn't do anything. I think what I need to do is run my dll through ngen and look at the assembly.

Answer 8

I'm guessing your code is like:

void DoSomethingIfCompFlag() {
#if COMPILER_FLAG
    //your code
#endif
}

This won't get optimised out, however:

partial void DoSomethingIfCompFlag();

#if COMPILER_FLAG
partial void DoSomethingIfCompFlag() {
    //your code
}
#endif

The first empty method is partial, and the C#3 compiler will optimise it out.

---

By the way: this is basically what partial methods are for. Microsoft added code generators to their Linq designers that need to call methods that by default don't do anything.

Rather than force you to overload the method you can use a partial.

This way the partials are completely optimised out if not used and no performance is lost, rather than adding the overhead of the extra empty method call.