Why Identical Delegates Behave Differently in C#

Performance differences between identical delegates in C# can reach up to 10x due to .NET JIT compiler behavior and delegate caching. This behavior is related to runtime optimization mechanics rather than your code logic.

Table of Contents

• Main Performance Reasons
• Role of JIT Compiler and Caching
• Method Inlining and Delegates
• Execution Order and Optimization
• Solutions and Best Practices
• Detailed Analysis of Your Example
• Conclusion

Main Performance Reasons

Your observation is explained by several key factors in how the .NET JIT compiler works:

1. Delegate caching: The JIT compiler caches created delegates, but this mechanism depends on the call order. As research indicates, “delegate caching created by lambda expressions depends on the compiler.”

2. First call vs subsequent calls: The first delegate call can be significantly slower due to the costs of JIT compilation and optimization of that specific execution path.

3. Lack of inlining: Delegates are almost never inlined, even if the JIT optimizer could determine the target method. Research shows that “callbacks through a delegate are never inlined.”

Role of JIT Compiler and Caching

The .NET JIT compiler applies several optimization strategies that directly affect delegate performance:

Delegate caching: According to research, “C# compiler does optimize this by caching the delegate and re-using it for both calls.” However, this mechanism doesn’t always work predictably.

In your case, the JIT compiler likely caches the first delegate when it’s executed, allowing subsequent calls to use already compiled code. The second delegate in the call order doesn’t receive this optimization, as the JIT compiler may treat them as different execution contexts.

Factors affecting caching:

• Order of creation and invocation
• Execution context (method where the delegate is created)
• Presence of first-call optimizations

Method Inlining and Delegates

One of the main reasons for performance differences is the lack of inlining for delegates:

// Direct method call (can be inlined)
uint result = test1(i, j);

// Call through delegate (never inlined)
var action = (uint x, uint y) => test1(x, y);
uint result = action(i, j);

As research shows, “callbacks through a delegate are never inlined even if the jitter optimizer could deduce what the delegate’s target method might be.” This means that instead of 2-3 assembly instructions, you might have 10-20 instructions when calling through a delegate.

Performance comparison:

• Direct method call: ~324 ms (in test)
• Call through delegate: ~1904 ms (in test)
• Virtual call: ~2714 ms (in test)

Execution Order and Optimization

Your observation about call order confirms that the JIT compiler applies optimizations based on execution history:

var del = () => arr.For((a) => test1(a.Item1, a.Item2));
var del2 = () => arr.For((a) => test1(a.Item1, a.Item2));

m(del);    // First call - cached, optimized
m(del2);   // Second call - may use cache, but not always

Why order matters:

1. JIT compiler tracks call patterns
2. After the first call, the method may be marked for optimization
3. Subsequent calls in the same context may use optimized code
4. Different delegates may be treated as different contexts, even if they’re identical

Solutions and Best Practices

To achieve stable delegate performance, the following is recommended:

1. Avoid recreating identical delegates

// Bad: creating new delegates in each iteration
for (int i = 0; i < count; i++)
{
    var action = () => Process(i);
    action();
}

// Good: create one delegate and reuse it
var action = () => { /* logic */ };
for (int i = 0; i < count; i++)
{
    action();
}

2. Use direct method calls where possible

// Instead of delegates for simple operations
uint result = i + j;  // Fast
// Instead of:
uint result = addDelegate(i, j);  // Slow

3. JIT “warming up”

// Execute the delegate once before the main loop
// to "warm up" the JIT compiler
del();

4. Use delegate caching

private static readonly Func<uint, uint, uint> CachedAdd = 
    (i, j) => i + j;

Detailed Analysis of Your Example

Your code demonstrates a classic case where the JIT compiler applies different optimization strategies:

Problem in the For method

public static void For<T>(this T[] arr, Action<T> func)
{
    int len = arr.Length; 
    foreach(var i in arr)
    {
        func(i);  // <-- Delegate call happens here
    }
}

Each call to func(i) is a delegate call that doesn’t get inlined. With 1,000,000 iterations, this creates enormous overhead.

Analysis of results

Your results show:

• First delegate: ~0.05 ms (fast)
• Second delegate: ~0.43 ms (8.6x slower)

This shows that the JIT compiler applied optimizations to the first delegate after the first call, but the second delegate is treated as a separate context.

Conclusion

The 10x performance difference between identical delegates occurs due to:

1. JIT caching: the first delegate call is cached and optimized
2. Lack of inlining: delegates are never inlined, creating additional instructions
3. Execution context: JIT treats different delegates as different contexts
4. Call order: early calls receive optimization benefits

Recommendations for improvement:

• Create delegates once and reuse them
• Avoid creating delegates inside hot loops
• Use direct method calls for simple operations
• Implement delegate caching for frequently used operations
• Apply JIT “warming up” before main computations

This behavior is a normal characteristic of .NET JIT compiler operation, not an error in your code. For maximum performance, always consider the trade-off between delegate flexibility and direct method calls.

Sources

1. Can the C# compiler or JIT optimize away a method call in a lambda expression? – Stack Overflow
2. C# delegate compiler optimisation – Stack Overflow
3. Are deterministically unchangable Actions, and Funcs Inlined by the JIT? – Stack Overflow
4. What optimization hints can I give to the compiler/JIT? – Stack Overflow
5. Compiled C# Lambda Expressions Performance – Stack Overflow