C# Lambda Closure Leak — Timer Crash After 48 Hours

using System;
using System.Runtime.CompilerServices;

public class LambdaCompilerBehaviour
{
    // ── CASE 1: No capture ────────────────────────────────────────────────
    // The compiler emits a static method and caches ONE delegate instance.
    // Re-using this Func thousands of times costs zero extra allocations.
    public static Func<int, int> GetDoublerNonCapturing()
    {
        // 'number' is the lambda parameter — not captured from outer scope
        Func<int, int> doubler = number => number * 2;
        return doubler;
    }

    // ── CASE 2: Captures a local variable ────────────────────────────────
    // Compiler creates a hidden 'DisplayClass' on the heap.
    // Every call to GetDoublerCapturing allocates a new closure object.
    public static Func<int, int> GetDoublerCapturing(int factor)
    {
        // 'factor' comes from the method parameter — this IS a capture
        Func<int, int> multiplier = number => number * factor;
        return multiplier;
    }

    public static void Main()
    {
        // Non-capturing: delegate is reused from the static cache
        var doubler = GetDoublerNonCapturing();
        Console.WriteLine($"Non-capturing result: {doubler(5)}");   // 10

        // Capturing: each call allocates a fresh closure + delegate
        var tripler  = GetDoublerCapturing(3);
        var quadrupler = GetDoublerCapturing(4);
        Console.WriteLine($"Tripler result  : {tripler(5)}");       // 15
        Console.WriteLine($"Quadrupler result: {quadrupler(5)}");   // 20

        // Prove they are independent objects — different factors captured
        Console.WriteLine($"Same delegate? {ReferenceEquals(tripler, quadrupler)}"); // False

        // ── CASE 3: Loop capture gotcha ───────────────────────────────────
        // Classic interview trap: all lambdas share the SAME closure variable
        var actions = new Action[3];
        for (int i = 0; i < 3; i++)
        {
            int snapshot = i; // fix: copy to a loop-local variable
            actions[i] = () => Console.WriteLine($"Snapshot value: {snapshot}");
        }

        foreach (var action in actions)
            action(); // prints 0, 1, 2 — not 3, 3, 3
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;

public class FuncActionComparison
{
    // ── Func: takes input(s), returns a value ─────────────────────────────
    // Func<TInput, TOutput> — last type param is ALWAYS the return type
    static Func<string, int> ParseLength = text => text.Length;

    // ── Action: takes input(s), returns nothing ───────────────────────────
    // Great for side-effects: logging, writing to DB, sending events
    static Action<string> LogMessage = message =>
        Console.WriteLine($"[LOG {DateTime.UtcNow:HH:mm:ss}] {message}");

    // ── Predicate: specialised Func<T, bool> ─────────────────────────────
    // Identical to Func<string, bool> but more semantically expressive
    static Predicate<string> IsLongWord = word => word.Length > 6;

    // ── Static lambda (C# 9+): enforces no capture at compile time ────────
    static Func<double, double> CircleArea = static radius => Math.PI * radius * radius;

    // ── Expression tree: lambda as DATA, not code ─────────────────────────
    // EF Core translates this to SQL; a plain Func<> would execute in-memory
    static Expression<Func<string, bool>> LongWordExpression = word => word.Length > 6;

    public static void Main()
    {
        // Func in action
        string sentence = "Lambda expressions are powerful";
        int wordCount = sentence.Split(' ').Sum(ParseLength);
        Console.WriteLine($"Total chars (no spaces): {wordCount}");  // 27

        // Action for side-effects
        LogMessage("Application started");

        // Predicate with List<T>.FindAll — predates generic Func
        var words = new List<string> { "C#", "delegates", "lambda", "closures", "IL" };
        List<string> longWords = words.FindAll(IsLongWord);
        Console.WriteLine($"Long words: {string.Join(", ", longWords)}");

        // Static lambda — can't accidentally capture
        double area = CircleArea(5.0);
        Console.WriteLine($"Circle area (r=5): {area:F4}");  // 78.5398

        // Expression tree — inspect it, don't just execute it
        Console.WriteLine($"Expression body: {LongWordExpression.Body}"); // (word.Length > 6)

        // Compile the expression to a delegate when you DO want to execute it
        Func<string, bool> compiledPredicate = LongWordExpression.Compile();
        Console.WriteLine($"'delegates' is long: {compiledPredicate("delegates")}"); // True

        // ── Chaining with Func: build a simple pipeline ───────────────────
        Func<string, string> trim     = s => s.Trim();
        Func<string, string> toLower  = s => s.ToLower();
        Func<string, string> sanitise = s => toLower(trim(s)); // manual composition

        Console.WriteLine(sanitise("  Hello World  "));  // hello world
    }
}

using System;
using System.Collections.Generic;

// ── Simulates a long-lived event source (e.g. a message bus singleton) ───
public class MessageBus
{
    // Storing delegates keeps all their captured variables alive
    private readonly List<Action<string>> _subscribers = new();

    public void Subscribe(Action<string> handler) => _subscribers.Add(handler);

    public void Publish(string message)
    {
        foreach (var subscriber in _subscribers)
            subscriber(message);
    }

    // Missing an Unsubscribe here is the leak — omitted intentionally to show the problem
}

// ── Short-lived processor that captures 'this' inside a lambda ────────────
public class OrderProcessor : IDisposable
{
    private readonly string _processorId;
    private readonly MessageBus _bus;
    private bool _disposed;

    // Large payload simulating a real object with meaningful state
    private readonly byte[] _largeCache = new byte[1024 * 1024]; // 1 MB

    public OrderProcessor(string processorId, MessageBus bus)
    {
        _processorId = processorId;
        _bus = bus;

        // PROBLEM: 'this' is implicitly captured because we access _processorId
        // MessageBus._subscribers now holds a reference chain:
        //   delegate -> closure -> this -> _largeCache (1 MB stays alive!)
        _bus.Subscribe(order => HandleOrder(order));
    }

    private void HandleOrder(string order)
    {
        if (_disposed) return; // guard, but memory is still not freed
        Console.WriteLine($"[{_processorId}] Processing: {order}");
    }

    // ── CORRECT PATTERN: capture only the value you need ─────────────────
    public static OrderProcessor CreateWithSnapshot(string processorId, MessageBus bus)
    {
        var processor = new OrderProcessor(processorId, bus);

        // Capture a value-type snapshot, not 'this'
        // The delegate no longer roots the entire OrderProcessor graph
        string idSnapshot = processorId;
        bus.Subscribe(order =>
            Console.WriteLine($"[SNAPSHOT:{idSnapshot}] {order}"));

        return processor;
    }

    public void Dispose()
    {
        _disposed = true;
        // In a real system: _bus.Unsubscribe(handler) — store handler ref to enable this
        Console.WriteLine($"[{_processorId}] Disposed — but lambda still in MessageBus!");
    }
}

public class ClosureMemoryBehaviour
{
    public static void Main()
    {
        var bus = new MessageBus(); // long-lived singleton

        // Short-lived processor — we call Dispose and null the ref,
        // but the lambda inside MessageBus still roots the 1 MB cache
        var processor = new OrderProcessor("OP-001", bus);
        bus.Publish("ORDER-42");

        processor.Dispose();
        processor = null!;       // local ref gone
        GC.Collect();            // GC runs
        GC.WaitForPendingFinalizers();

        // bus._subscribers still holds the delegate -> _largeCache is NOT collected
        Console.WriteLine("Processor nulled and GC ran — memory leak in place.");

        // Publishing again still works because closure is still alive
        bus.Publish("ORDER-43"); // prints [OP-001] Processing: ORDER-43
    }
}

using System;
using System.Diagnostics;

public class LambdaPerformanceComparison
{
    private const int Iterations = 10_000_000;

    // ── Option 1: Direct static method call ──────────────────────────────
    // Fastest possible — the JIT inlines this with zero indirection
    private static double ComputeCircleArea(double radius) => Math.PI * radius * radius;

    // ── Option 2: Non-capturing static lambda ────────────────────────────
    // Compiler emits a static method + one cached delegate; zero ongoing allocation
    private static readonly Func<double, double> CircleAreaDelegate =
        static radius => Math.PI * radius * radius;

    // ── Option 3: Capturing lambda (re-created on every call) ─────────────
    // Returns a NEW closure object each time — heap pressure in a tight loop
    private static Func<double, double> BuildCapturingDelegate(double factor)
    {
        // 'factor' is captured — forces closure allocation
        return radius => Math.PI * radius * radius * factor;
    }

    public static void Main()
    {
        double total = 0;
        var sw = Stopwatch.StartNew();

        // ── Benchmark 1: Direct static method ────────────────────────────
        sw.Restart();
        for (int i = 1; i <= Iterations; i++)
            total += ComputeCircleArea(i);
        long directMs = sw.ElapsedMilliseconds;
        Console.WriteLine($"Direct static method : {directMs} ms  (total={total:E2})");

        // ── Benchmark 2: Cached non-capturing delegate ────────────────────
        total = 0;
        sw.Restart();
        for (int i = 1; i <= Iterations; i++)
            total += CircleAreaDelegate(i);
        long cachedDelegateMs = sw.ElapsedMilliseconds;
        Console.WriteLine($"Cached delegate      : {cachedDelegateMs} ms  (total={total:E2})");

        // ── Benchmark 3: Capturing lambda re-created per outer call ───────
        // Simulates a pattern like: services.AddTransient(sp => BuildPipeline(config))
        total = 0;
        sw.Restart();
        for (int i = 1; i <= Iterations; i++)
        {
            // BUG PATTERN: building a new delegate on every loop tick
            var capturingFunc = BuildCapturingDelegate(1.0); // new closure each time
            total += capturingFunc(i);
        }
        long capturingMs = sw.ElapsedMilliseconds;
        Console.WriteLine($"Capturing (per-iter) : {capturingMs} ms  (total={total:E2})");

        Console.WriteLine();
        Console.WriteLine("Key insight: cached non-capturing delegates approach direct-call speed.");
        Console.WriteLine("Re-creating capturing delegates in a loop is the real performance killer.");
    }
}

using System;
using System.Threading.Tasks;
using System.Threading;

public class AsyncLambdaBehaviour
{
    // ── PROBLEM: Async lambda stored as Action ─────────────────────────────
    // Exceptions are unobserved; fire-and-forget can crash the process
    public static Action AsyncActionLeak = async () =>
    {
        await Task.Delay(10);
        // If this throws, the exception is swallowed
        throw new InvalidOperationException("Silent crash");
    };

    // ── CORRECT: Use Func<Task> for async callbacks ───────────────────────
    public static Func<Task> AsyncFuncCorrect = async () =>
    {
        await Task.Delay(10);
        // Caller can await this and observe exceptions
    };

    public static async Task Main()
    {
        // Fire the bad pattern — exception goes unobserved
        try
        {
            AsyncActionLeak(); // No await possible - fire and forget
        }
        catch (Exception ex)
        {
            // This catch block NEVER executes
            Console.WriteLine($"Caught: {ex.Message}");
        }

        // Wait a bit for the exception to (maybe) crash
        await Task.Delay(100);
        Console.WriteLine("Survived the silent exception? Check Application Insights.");

        // Correct invocation
        await AsyncFuncCorrect(); // Exception is properly observed
        Console.WriteLine("Async Func completed safely.");
    }
}

// io.thecodeforge — csharp tutorial

Func<int>[] BuildLeakyCache()
{
    var cache = new Func<int>[100];
    for (int i = 0; i < cache.Length; i++)
    {
        // Captures 'i' by reference — display class allocated per iteration
        cache[i] = () => i;
    }
    return cache;
}

// Static lambda — no capture, single delegate reused
Func<int, int> StaticSquare = static (x) => x * x;

var leaky = BuildLeakyCache();
Console.WriteLine(leaky[0]());  // Outputs 100 -- closure captured the loop variable

// io.thecodeforge — csharp tutorial

using System.Linq.Expressions;

// Wrong — forces client-side evaluation
Func<Customer, bool> badPredicate = c => c.TotalOrders > 1000;

// Right — EF Core translates this to WHERE clause
Expression<Func<Customer, bool>> goodPredicate = c => c.TotalOrders > 1000;

// Simulated usage
var customers = new List<Customer>();
// badPredicate: all rows loaded, filtered in memory
var badResult = customers.Where(badPredicate);
// goodPredicate: translated to SQL, filtered in database
var goodResult = customers.AsQueryable().Where(goodPredicate);

Console.WriteLine(badResult.GetType());  // IEnumerable
Console.WriteLine(goodResult.GetType()); // IQueryable

// io.thecodeforge — csharp tutorial
// Events vs delegate fields — why events exist
public class Button
{
    // Event prevents external invocation/reset
    public event Action? Clicked;

    // Without event: public Action? Clicked; // Danger!

    public void SimulateClick()
    {
        // Only Button can raise Clicked
        Clicked?.Invoke();
    }
}

// Consumer code:
var btn = new Button();
btn.Clicked += () => Console.WriteLine("Clicked!");
// btn.Clicked?.Invoke(); // Compile error — not allowed
// btn.Clicked = null; // Compile error — not allowed

// io.thecodeforge — csharp tutorial
// Standard event pattern with EventArgs
public class FileDownloader
{
    public event EventHandler<DownloadArgs>? DownloadComplete;

    protected virtual void OnDownloadComplete(DownloadArgs args)
    {
        DownloadComplete?.Invoke(this, args);
    }

    public void Download()
    {
        // ... work ...
        OnDownloadComplete(new DownloadArgs("success", 1024));
    }
}

public class DownloadArgs : EventArgs
{
    public string Status { get; }
    public long Bytes { get; }
    public DownloadArgs(string status, long bytes) => (Status, Bytes) = (status, bytes);
}