Does setting a function public affect the C# compiler's ability to inline the function as an optimization?

Question

This could be either for the .NET or Mono compilers.

I know that under certain conditions the compiler can inline functions (e.g. small, single call site, etc.) as an optimization. However, if the function is public, then it needs to have an external entry point.

In these cases, is duplicated code generated (public entry point which isn't used by the internal code since the internal code uses the inlined version), or does marking it as public prevent the compiler from doing such an optimization?

• svick: I'm quite sure public doesn't affect inlining in any way. And I'm really not sure what "external entry point" is supposed to mean.
• Eric King: Write out a small class, compile it once with public and once with private, and then compare the IL. That'll give you the definitive answer...
• Esailija: The IL is completely useless to answer any kind of optimization or performance question - always check the generated machine code from JIT.

Answer 1

I found this interesting article on C# inline methods.

Scope of a method doesn't appear to change when a function becomes an inline candidate. Here is a summary of that article.

How to determine what get’s inlined? The short answer is that you can’t. The MSDN article "Writing High-Performance Managed Applications : A Primer" gives the following guidance:

1. Methods that are greater than 32 bytes of IL will not be inlined.
2. Virtual functions are not inlined.
3. Methods that have complex flow control will not be in-lined. Complex flow control is any flow control other than if/then/else; in this case, switch or while.
4. Methods that contain exception-handling blocks are not inlined, though methods that throw exceptions are still candidates for inlining.
5. If any of the method’s formal arguments are structs, the method will not be inlined.

There is no inline keyword in C#, but there is an inline compiler directive that was introduced in .NET 4.5 called MethodImplOptions.AggressiveInlining

It can be used like this.

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static int Method2()
{
// ... Aggressive inlining.
return "one".Length + "two".Length + "three".Length +
 "four".Length + "five".Length + "six".Length +
 "seven".Length + "eight".Length + "nine".Length +
 "ten".Length;
}

You can't know for sure if the compiler will inline a function. This isn't feature C# developers have control over.