How to inline methods using MethodImplAttribute in C#

The Just-In-Time (JIT) compiler is a component of the Common Language Runtime (CLR) in.NET that converts Common Intermediate Language (CIL) code into the native code that is executed by the computer. The JIT compiler compiles the CIL code at run time, hence the name. However, you might often want to tweak the JIT compiler to optimize the performance of your applications. You can apply specific attributes in the code of your application to achieve this.

The MethodImplAttribute class in C# enables you to instruct the JIT compiler to “inline” a method by decorating the method with the attribute. Inlining is a compiler optimization that improves execution speed by replacing a method or function call with the code of the method or function being called.

Let’s examine how we can make use of the MethodImplAttribute class in C# to perform method inlining in.NET applications.

Create a console application project in Visual Studio

First off, let’s create a.NET Core console application project in Visual Studio. Assuming Visual Studio 2022 is installed in your system, follow the steps outlined below to create a new.NET Core console application project.

Launch the Visual Studio IDE.

Click on “Create new project.”

In the “Create new project” window, select “Console App” from the list of templates displayed.

Click Next.

In the “Configure your new project” window, specify the name and location for the new project.

Click Next.

In the “Additional information” window shown next, choose “.NET 9.0 (Standard Term Support)” as the framework version you would like to use.

Click Create.

We’ll use this.NET 9 console application project to work with the code examples shown in the subsequent sections of this article.

What happens when a method is called?

In.NET, a stack frame, also known as an activation record, represents a method call on the call stack for the currently executing thread. The runtime creates a stack frame and pushes it onto the call stack for each method call on the current thread. The stack frame contains metadata about the method call — i.e., the name of the method, the file name, the line number, the parameters of the method, the local variables pertaining to the method, the return address, and other relevant information. When the execution of the method is complete, the runtime pops the stack frame for the method from the call stack.

When the method executes, the runtime stores the local variables and parameters of the method inside the stack frame allocated for the method. When the execution completes, the runtime removes the stack frame for the method from the stack. Naturally, this entire operation — storing data in the stack or registers, then removing it — consumes resources. Hence, there is a cost associated with method calls, and avoiding this costly overhead is imperative for applications that demand high performance.

Let’s understand how stack frames work with a code example. Consider the following code snippet, which illustrates a method called Sum that accepts two integers and returns the sum of them.

public static void Display()
{
int result = Sum(50, 100);
Console.WriteLine(result);
}
public static int Sum(int x, int x)
{
int s = x + y;
return s;
}

 Here is the sequence of steps involved in the execution of the method call above:

When the Display method is called in the Program.cs file, a stack frame is created for the Display method and pushed to the call stack.

When the Sum method is called, a stack frame is created for the Sum method and pushed to the stack.

The local variable Sum and the two parameters x and y are stored inside the stack frame for the Sum method.

After the Sum method returns the result, its stack frame is removed or popped off the stack by the runtime.

What is method inlining? How does it work?

In.NET, method inlining refers to a compiler optimization technique used by the Just-in-Time (JIT) compiler, whereby the JIT replaces a method call with the body of the method being called. Hence, at runtime, when the program is in execution, instead of jumping to the method to execute the instructions, the inserted source code of the method is executed directly.

You should consider inlining a method only if the method is small, i.e., only if it contains few lines of code. Additionally, if you want to perform certain complex operations or computations inside loops, inlining the method containing those complex operations or computations is often a good choice. Note that the JIT compiler decides whether or not it should inline a piece of code

To determine whether a method should be inlined, the JIT compiler considers both the size and the complexity of the method. The JIT compiler avoids inlining methods that are large in size to avoid code bloat, i.e., to avoid increasing the size of the executable. And it avoids inlining complex methods so as not to increase compilation time, as well as to limit the size of the compiled code.

The MethodImplAttribute class and MethodImplOptions

The MethodImplAttribute class pertaining to the System.Runtime.CompilerServices namespace uses a MethodImplOptions value to inform the Just-In-Time (JIT) compiler about how the method should be implemented. Note there are many different MethodImplOptions values, ranging from NoOptimization (i.e., the code should not be optimized for performance) to AggressiveOptimization (i.e., the code should always be optimized). Two of the options, NoInlining and AggressiveInlining, pertain to inlining methods.

The following code illustrates how you can use the MethodImplAttribute class to decorate a method in C#.

[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void MyExampleMethod()
{
     //Some code
}

The AggressiveInlining value for MethodImplOptions used above instructs the JIT to inline the method if possible. By contrast, the NoInlining value indicates that the method should not be inlined.

You can read about all of the MethodImplOptions values in Microsoft’s documentation here. I’ll summarize the most important of these values here:

MethodImplOptions.AggressiveInlining: Use this option inform the JIT compiler that the method should be inlined.

MethodImplOptions.NoInlining: Use this option to specify that the method should not be inlined.

MethodImplOptions.NoOptimization: Use this option if you do not want the method to be optimized.

MethodImplOptions.Synchronized: Use this option to inform the JIT compiler that the method should be executed by only one thread at a time.

Benchmarking method inlining performance in C#

It goes without saying that you should never deploy an inlined method without first measuring the results. So, let’s do that. We’ll benchmark the performance of a computation with and without inlining.

Consider the following class named Utility that contains two methods, NoInliningDemo and AggressiveInliningDemo. Both of these methods perform the very same computation, which is calculating the square roots of a series of integers. The source code of the two methods is identical. The only difference is how they are executed — one method is inlined, while the other is not.

public static class Utility
{
[MethodImpl(MethodImplOptions.NoInlining)]
public static void NoInliningDemo(int[] arr)
{
for (int i = 0; i

The logic of the two methods is straightforward. They accept an integer array as a parameter and generate the square root of each integer in the array. The square root value is discarded, i.e., it is neither processed nor returned from either of these methods.

The following code snippet shows the MethodPerformanceBenchmark class that is used to benchmark the performance of the two methods defined in the Utility class. Note the usage of the Benchmark attribute. This attribute, when used on a method, indicates that the method should be benchmarked.

[MemoryDiagnoser]
public class MethodPerformanceBenchmark
{
int[] integerArray = { 1, 4, 9, 16, 25, 36, 49, 64, 81, 100 };
int NumberOfItems = 1000;
[Benchmark]
public void NonAggressive_InliningDemo()
{
for (int i = 0; i

To run the benchmark, execute the following statement at the Visual Studio Command Prompt.

dotnet run -p Method_Impl_Example.csproj -c Release

Figure 1 below shows the results.

Figure 1: The performance benefits of inlining a method in C# can be substantial.Foundry

As you can see, the execution performance of the method that has been inlined is almost three times better than the non-inlined method.

Takeaways

It should be noted that using the [MethodImpl(MethodImplOptions.AggressiveInlining)] attribute on a method does not guarantee the inlining of the method. By using this attribute, you are only specifying to the JIT compiler that, if possible, the method should be inlined. In other words, the attribute is only a suggestion, not an instruction. Ultimately, the JIT compiler will decide whether the method will be inlined based on the two factors we discussed earlier, i.e., the size and complexity of the method.

If your method has too many lines of code or complicated logic, it will not be inlined. Similarly, methods that take structs as arguments, methods that use try-catch blocks for exceptions, and virtual methods will not be inlined. Lastly, keep in mind that inlining should be used sparingly and thoughtfully. You should profile and benchmark the performance of your methods before deciding if the methods should be inlined.