Delegates, Lambdas and Events

public static class BuiltInDelegates
{
    public static void Run()
    {
        Func<decimal, decimal> discount = amount => amount * 0.9m;  // returns a value
        Action<string> log = message => Console.WriteLine(message); // returns void
        Predicate<int> isEven = n => n % 2 == 0;                    // Func<int, bool> by another name

        Console.WriteLine(discount(100m));
        log("applied");
        Console.WriteLine(isEven(4));

        Func<int, int, int> add = (a, b) => a + b;        // up to 16 parameters
        Action noArguments = () => log("nothing to see"); // no parameters, no result
        Console.WriteLine(add(2, 3));
        noArguments();
    }
}

public static class Multicast
{
    public static void Run()
    {
        Action<string> pipeline = m => Console.WriteLine($"console: {m}");
        pipeline += m => Console.WriteLine($"audit:   {m}");

        pipeline("saved");     // both run, in the order they were added

        Console.WriteLine(pipeline.GetInvocationList().Length);   // 2

        // Combining is not mutation: delegates are immutable, += builds a new instance.
        Action<string> single = m => Console.WriteLine(m);
        Action<string> combined = single + (m => Console.WriteLine(m.ToUpperInvariant()));
        Console.WriteLine(ReferenceEquals(single, combined));     // False
    }
}

public static class IsolatedInvocation
{
    public static void RaiseSafely(Action<string> handlers, string message)
    {
        foreach (Action<string> handler in handlers.GetInvocationList().Cast<Action<string>>())
        {
            try
            {
                handler(message);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"subscriber failed: {ex.Message}");
            }
        }
    }
}

public static class LambdaNaturalType
{
    public static void Run()
    {
        var increment = (int x) => x + 1;             // inferred as Func<int, int>
        Console.WriteLine(increment.GetType().Name);  // Func`2

        // C# 12: default parameter values on lambdas.
        var pad = (string s, int width = 10) => s.PadLeft(width);
        Console.WriteLine($"[{pad("hi")}] [{pad("hi", 4)}]");

        // C# 11: attributes on lambdas and on their parameters.
        var parse = [return: NotNullIfNotNull(nameof(text))] (string? text) =>
            text is null ? null : text.Trim();
        Console.WriteLine(parse(" x ") ?? "<null>");
    }
}

public static class StaticLambdas
{
    public static void Run()
    {
        int outside = 5;

        Func<int, int> pure = static x => x * 2;   // cannot see `outside` -- by design
        Console.WriteLine(pure(outside));

        // Marking this one static would be a compile error: it captures `outside`.
        Func<int, int> capturing = x => x * outside;
        Console.WriteLine(capturing(3));
    }
}

public delegate bool TryParseDelegate<T>(string text, out T result);

public static class LambdaModifiers
{
    public static void Run()
    {
        // C# 14: `out result` needs no explicit type -- it is inferred from the delegate.
        TryParseDelegate<int> tryParse = (text, out result) => int.TryParse(text, out result);

        if (tryParse("42", out int value))
        {
            Console.WriteLine(value);   // 42
        }
    }
}

public static class LoopCapture
{
    public static void Run()
    {
        var fromForeach = new List<Func<int>>();
        foreach (int i in Enumerable.Range(0, 3))
        {
            fromForeach.Add(() => i);        // since C# 5: a fresh `i` per iteration
        }
        Console.WriteLine(string.Join(",", fromForeach.Select(f => f())));   // 0,1,2

        var fromFor = new List<Func<int>>();
        for (int i = 0; i < 3; i++)
        {
            fromFor.Add(() => i);            // ONE `i` for the whole loop -- all see 3
        }
        Console.WriteLine(string.Join(",", fromFor.Select(f => f())));       // 3,3,3

        var fixedUp = new List<Func<int>>();
        for (int i = 0; i < 3; i++)
        {
            int copy = i;                    // a per-iteration local restores the intuition
            fixedUp.Add(() => copy);
        }
        Console.WriteLine(string.Join(",", fixedUp.Select(f => f())));       // 0,1,2
    }
}

public static class AvoidingCapture
{
    public static void Run()
    {
        var cache = new Dictionary<string, int>();
        string key = "answer";

        // Captures `key` -- allocates a display class and a delegate on every call.
        int captured = cache.TryGetValue(key, out int found) ? found : ComputeFor(key);

        // Overloads taking a state argument let the lambda stay static.
        int viaState = cache.TryGetValue(key, out int hit)
            ? hit
            : StaticFactory(key, static k => ComputeFor(k));

        Console.WriteLine($"{captured} {viaState}");
    }

    private static int ComputeFor(string key) => key.Length;

    private static int StaticFactory(string key, Func<string, int> factory) => factory(key);
}

public static class AnonymousMethods
{
    public static void Run()
    {
        Func<int, int> old = delegate (int x) { return x * 2; };
        Action<string> ignoringParameters = delegate { Console.WriteLine("something happened"); };

        Console.WriteLine(old(21));
        ignoringParameters("unused");
    }
}

public sealed class FileFoundEventArgs : EventArgs
{
    public FileFoundEventArgs(string path) => Path = path;

    public string Path { get; }
    public bool Cancel { get; set; }     // let a subscriber stop the operation
}

public class FileSearcher
{
    public event EventHandler<FileFoundEventArgs>? FileFound;

    public void Search(IEnumerable<string> candidates)
    {
        foreach (string candidate in candidates)
        {
            var args = new FileFoundEventArgs(candidate);
            OnFileFound(args);
            if (args.Cancel)
            {
                break;
            }
        }
    }

    protected virtual void OnFileFound(FileFoundEventArgs e) => FileFound?.Invoke(this, e);
}

public sealed class SparseEvents
{
    private readonly Dictionary<string, Delegate?> _handlers = new();
    private readonly Lock _gate = new();          // System.Threading.Lock, C# 13 / .NET 9

    public event EventHandler? Saved
    {
        add
        {
            lock (_gate)
            {
                _handlers["Saved"] = Delegate.Combine(_handlers.GetValueOrDefault("Saved"), value);
            }
        }
        remove
        {
            lock (_gate)
            {
                _handlers["Saved"] = Delegate.Remove(_handlers.GetValueOrDefault("Saved"), value);
            }
        }
    }

    public void RaiseSaved()
    {
        Delegate? handler;
        lock (_gate)
        {
            handler = _handlers.GetValueOrDefault("Saved");
        }
        (handler as EventHandler)?.Invoke(this, EventArgs.Empty);
    }
}

// One file -- typically hand-written -- declares the event.
public partial class Telemetry
{
    public partial event EventHandler<string> MessageLogged;

    public void Log(string message) => OnMessageLogged(message);
}

// Another file -- typically generated -- supplies the implementation.
public partial class Telemetry
{
    private EventHandler<string>? _messageLogged;

    public partial event EventHandler<string> MessageLogged
    {
        add => _messageLogged += value;
        remove => _messageLogged -= value;
    }

    private void OnMessageLogged(string message) => _messageLogged?.Invoke(this, message);
}

public sealed class Window
{
    private readonly Downloader _downloader;
    private readonly EventHandler<int> _handler;

    public Window(Downloader downloader)
    {
        _downloader = downloader;

        // Keep the delegate in a field so the exact same instance can be removed later.
        _handler = (sender, percent) => Console.WriteLine(percent);
        _downloader.ProgressChanged += _handler;
    }

    public void Close() => _downloader.ProgressChanged -= _handler;
}