What is a delegate in C#? Explain what a delegate object contains, how it is created and invoked, delegate equality, how instance and static method targets differ, what allocations happen, and how delegates compare with interfaces and function pointers.

1. Delegate types are classes

public delegate decimal DiscountRule(Order o); compiles to:

public sealed class DiscountRule : MulticastDelegate
{
    public DiscountRule(object target, IntPtr method);
    public virtual decimal Invoke(Order o);                         // implemented by the runtime
    public virtual IAsyncResult BeginInvoke(Order o, AsyncCallback cb, object state);  // not supported on .NET Core
    public virtual decimal EndInvoke(IAsyncResult result);
}

Invoke has no IL body — the runtime provides it. BeginInvoke/EndInvoke throw PlatformNotSupportedException on .NET Core; use Task.Run instead.

2. How invocation works

• Single-cast instance delegate: Invoke loads _target into the this register and jumps to _methodPtr.
• Static method delegate: _methodPtr points to a shuffle thunk that shifts arguments, then jumps to _methodPtrAux (the real method).
• Multicast: Invoke iterates the invocation list and calls each.
• Delegates to virtual methods resolve the target method at creation (ldvirtftn).

3. Compiler caching of delegates

• Non-capturing lambdas: compiled to instance methods on a singleton <>c class; the delegate is cached in a static field on first use.
• Static method groups: since C# 11, Func<int,int> f = Math.Abs; caches the delegate in a static field too.
• Instance method groups and capturing lambdas: new delegate per evaluation.

4. Function pointers

unsafe
{
    delegate*<int, int, int> add = &Add;
    int r = add(1, 2);
}
static int Add(int a, int b) => a + b;

• delegate* managed<...> for managed static methods; delegate* unmanaged[Cdecl]<...> for native callbacks ([UnmanagedCallersOnly]).
• No allocation, no target, no multicast.
• Used in high-performance interop (LibraryImport, CsWin32) and runtime internals.

5. Delegates and the JIT

Delegate calls are indirect and normally not inlined. With dynamic PGO (.NET 8+), the JIT can perform guarded devirtualisation for delegates: if a call site almost always invokes the same method, it checks _methodPtr and calls/inlines that method directly. This reduces the cost of LINQ predicates and callbacks in hot loops.

6. Delegates and memory leaks

A delegate holds a strong reference to its target. Storing delegates in long-lived places (static events, singletons, caches) keeps targets alive — the classic event-handler leak. Use weak event patterns, unsubscribe in Dispose, or avoid capturing large objects.

Try it yourself

1. Inspect rule.Method and rule.Target for instance, static and lambda delegates.
2. Benchmark allocations of a capturing lambda vs a static lambda vs a cached delegate.
3. Try removing a lambda handler with -= using an identical-looking lambda.
4. Write a function pointer call and compare with a delegate call in BenchmarkDotNet.

namespace Delegates.Basics;

public sealed record Order(decimal Total, bool IsLoyaltyMember);

public delegate decimal PriceRule(Order order, decimal currentPrice);

public sealed class LoyaltyDiscount(decimal rate)
{
    public decimal Apply(Order order, decimal price) => order.IsLoyaltyMember ? price * (1 - rate) : price;
}

public static class Rules
{
    public static decimal AddGst(Order order, decimal price) => price * 1.10m;
}

public sealed class PricingEngine(IReadOnlyList<PriceRule> rules)
{
    public decimal Price(Order order)
    {
        var price = order.Total;
        foreach (var rule in rules) price = rule(order, price);
        return decimal.Round(price, 2);
    }
}

public static class Program
{
    public static void Main()
    {
        var loyalty = new LoyaltyDiscount(0.05m);

        PriceRule discount = loyalty.Apply;   // instance target captured
        PriceRule gst = Rules.AddGst;         // static, cached since C# 11
        PriceRule promo = (o, p) => o.Total > 100m ? p - 10m : p;

        var engine = new PricingEngine([discount, promo, gst]);
        Console.WriteLine(engine.Price(new Order(150m, IsLoyaltyMember: true)));

        Console.WriteLine(discount.Target == loyalty);       // True: delegate keeps loyalty alive
        Console.WriteLine(gst.Target is null);              // True: static method
        Console.WriteLine(discount.Method.Name);            // Apply

        PriceRule again = loyalty.Apply;
        Console.WriteLine(discount == again);               // True: same target and method
        Console.WriteLine(ReferenceEquals(discount, again)); // False: two objects
    }
}