The way to inline strategies utilizing MethodImplAttribute in C#

• MethodImplOptions.AggressiveInlining: Use this selection inform the JIT compiler that the tactic ought to be inlined.
• MethodImplOptions.NoInlining: Use this selection to specify that the tactic shouldn’t be inlined.
• MethodImplOptions.NoOptimization: Use this selection if you don’t want the tactic to be optimized.
• MethodImplOptions.Synchronized: Use this selection to tell the JIT compiler that the tactic ought to be executed by just one thread at a time.

Benchmarking technique inlining efficiency in C#

It goes with out saying that it’s best to by no means deploy an inlined technique with out first measuring the outcomes. So, let’s do this. We’ll benchmark the efficiency of a computation with and with out inlining.

Think about the next class named Utility that comprises two strategies, NoInliningDemo and AggressiveInliningDemo. Each of those strategies carry out the exact same computation, which is calculating the sq. roots of a sequence of integers. The supply code of the 2 strategies is similar. The one distinction is how they’re executed — one technique is inlined, whereas the opposite shouldn’t be.

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

The logic of the 2 strategies is easy. They settle for an integer array as a parameter and generate the sq. root of every integer within the array. The sq. root worth is discarded, i.e., it’s neither processed nor returned from both of those strategies.

The next code snippet exhibits the MethodPerformanceBenchmark class that’s used to benchmark the efficiency of the 2 strategies outlined within the Utility class. Notice the utilization of the Benchmark attribute. This attribute, when used on a technique, signifies that the tactic ought to 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 next assertion on the Visible Studio Command Immediate.

dotnet run -p Method_Impl_Example.csproj -c Launch

Determine 1 beneath exhibits the outcomes.