Delegates, Func and Action

// A delegate type names a shape of method: here, one decimal in and one decimal out. A variable of that type holds a
// method of that shape, and calling the variable calls the method. The prices and rules are made up for this lesson.
PriceRule rule = Rules.Festival;
Console.WriteLine($"Festival:  Rs {rule(800m)}");
Console.WriteLine($"Invoke:    Rs {rule.Invoke(800m)}");
Console.WriteLine($"  method {rule.Method.Name}, target {Describe(rule.Target)}");

// The same variable now holds an instance method, so the delegate also keeps the object to call it on.
var shop = new Shop(fee: 40m);
rule = shop.WithDelivery;
Console.WriteLine($"Delivery:  Rs {rule(800m)}");
Console.WriteLine($"  method {rule.Method.Name}, target {Describe(rule.Target)}");

// A lambda of the same shape converts to the same delegate type.
rule = price => price >= 1000m ? price - 150m : price;
Console.WriteLine($"Lambda:    Rs {rule(800m)} and Rs {rule(1200m)}");

Console.WriteLine($"The type of rule: {rule.GetType().Name}, derived from {rule.GetType().BaseType!.FullName}");

static string Describe(object? target) => target is null ? "none (a static method)" : target.ToString()!;

static class Rules
{
    // 10 % off.
    public static decimal Festival(decimal price) => price * 90 / 100;
}

class Shop(decimal fee)
{
    public decimal WithDelivery(decimal price) => price + fee;

    public override string ToString() => $"the Shop with a delivery fee of Rs {fee}";
}

delegate decimal PriceRule(decimal price);

Festival:  Rs 720
Invoke:    Rs 720
  method Festival, target none (a static method)
Delivery:  Rs 840
  method WithDelivery, target the Shop with a delivery fee of Rs 40
Lambda:    Rs 800 and Rs 1050
The type of rule: PriceRule, derived from System.MulticastDelegate

// Two assignments the compiler refuses. Round has a second parameter, so it does not have the shape of PriceRule.
// Predicate<string> and Func<string, bool> have the same shape, but they are two different types.
PriceRule rule = Rules.Round;

Predicate<string> isBlank = string.IsNullOrWhiteSpace;
Func<string, bool> test = isBlank;

Console.WriteLine(rule(799.5m));
Console.WriteLine(test(" "));

static class Rules
{
    public static decimal Round(decimal price, int digits) => Math.Round(price, digits);
}

delegate decimal PriceRule(decimal price);

from session import run

# mismatch assigns a method with two parameters to PriceRule, and a Predicate<string> to a Func<string, bool>.
# dotnet run builds the project first and stops at the errors.
run("""
cd mismatch
!dotnet run
""")

$ cd mismatch
$ dotnet run
mismatch/Program.cs(3,24): error CS0123: No overload for 'Round' matches delegate 'PriceRule' [mismatch/App.csproj]
mismatch/Program.cs(6,27): error CS0029: Cannot implicitly convert type 'System.Predicate<string>' to 'System.Func<string, bool>' [mismatch/App.csproj]

The build failed. Fix the build errors and run again.
[exit status 1]

// The built-in delegate families: Func returns a value (its last type argument), Action returns nothing, Predicate<T>
// answers yes or no about one value. A custom delegate type covers what they cannot express: an out parameter.
using System.Globalization;

Func<decimal, decimal, decimal> addGst = (price, ratePercent) => price + price * ratePercent / 100;
Action<string> log = message => Console.WriteLine($"log: {message}");
Predicate<int> isLow = units => units < 5;

log($"Rs 1000 with 18 % GST is Rs {addGst(1000m, 18m)}");
log($"3 units left, low: {isLow(3)}");

// List<T>.FindAll takes a Predicate<T>; LINQ's Count takes a Func<T, bool>. The same test, two delegate types.
List<int> stock = [12, 3, 0, 7, 4];
List<int> low = stock.FindAll(isLow);
log($"FindAll found {low.Count} low: {string.Join(", ", low)}");
log($"Count with a Func<int, bool>: {stock.Count(units => units < 5)}");

// To pass the Predicate where a Func is wanted, pass its Invoke method: a method group of the right shape.
Func<int, bool> sameTest = isLow.Invoke;
log($"Count with isLow.Invoke: {stock.Count(sameTest)}");

// Parsing hands back its result through an out parameter, which Func and Action cannot declare.
TryParser<int> parseUnits = (string text, out int value) => int.TryParse(text, out value);
// C# 14: a modifier such as out no longer needs the parameter's type.
TryParser<decimal> parsePrice = (text, out value) => decimal.TryParse(text, CultureInfo.InvariantCulture, out value);

foreach (string text in new[] { "42", "4.5", "lots" })
{
    bool isUnits = parseUnits(text, out int units);
    bool isPrice = parsePrice(text, out decimal price);
    string unitsText = isUnits ? units.ToString(CultureInfo.InvariantCulture) : "no";
    string priceText = isPrice ? price.ToString(CultureInfo.InvariantCulture) : "no";
    log($"\"{text}\": units {unitsText}, price {priceText}");
}

delegate bool TryParser<T>(string text, out T value);

log: Rs 1000 with 18 % GST is Rs 1180
log: 3 units left, low: True
log: FindAll found 3 low: 3, 0, 4
log: Count with a Func<int, bool>: 3
log: Count with isLow.Invoke: 3
log: "42": units 42, price 42
log: "4.5": units no, price 4.5
log: "lots": units no, price no

// One Price method serves every discount rule, because the rule is a parameter. The amounts are made up for this lesson.
decimal cart = 2000m;

Console.WriteLine($"no discount:       Rs {Price(cart, NoDiscount)}");
Console.WriteLine($"festival 10 %:     Rs {Price(cart, Festival)}");
Console.WriteLine($"coupon Rs 100:     Rs {Price(cart, amount => amount - 100m)}");
Console.WriteLine($"member 15 %:       Rs {Price(cart, PercentOff(15))}");
Console.WriteLine($"coupon Rs 2,500:   Rs {Price(cart, amount => amount - 2500m)}");

// Rules in a list, applied one after another: the order changes the total.
Func<decimal, decimal> coupon = amount => amount - 100m;
Console.WriteLine($"10 % then Rs 100:  Rs {PriceAll(cart, [Festival, coupon])}");
Console.WriteLine($"Rs 100 then 10 %:  Rs {PriceAll(cart, [coupon, Festival])}");

// The rule is the only thing that varies; Price never goes below zero, whatever rule it is given.
static decimal Price(decimal amount, Func<decimal, decimal> rule) => Math.Max(0m, rule(amount));

static decimal PriceAll(decimal amount, Func<decimal, decimal>[] rules)
{
    foreach (Func<decimal, decimal> rule in rules)
    {
        amount = rule(amount);
    }

    return Math.Max(0m, amount);
}

static decimal NoDiscount(decimal amount) => amount;

static decimal Festival(decimal amount) => amount * 90 / 100;

// A method that makes a rule: the lambda it returns remembers percent (the next lesson explains how).
static Func<decimal, decimal> PercentOff(int percent) => amount => amount * (100 - percent) / 100;

no discount:       Rs 2000
festival 10 %:     Rs 1800
coupon Rs 100:     Rs 1900
member 15 %:       Rs 1700
coupon Rs 2,500:   Rs 0
10 % then Rs 100:  Rs 1700
Rs 100 then 10 %:  Rs 1710

// One delegate with three targets. += does not change a delegate: it makes a new one whose invocation list has one
// more method, and the variable now refers to the new delegate.
Action<string> notify = Sms;
notify += Email;
notify += Push;
Console.WriteLine($"notify has {notify.GetInvocationList().Length} targets");
notify("Order 4519 shipped");

// A copy taken before += keeps the old list.
Action<string> before = notify;
notify += Sms;
Console.WriteLine($"after one more +=: notify has {notify.GetInvocationList().Length}, before still has {before.GetInvocationList().Length}");

// -= removes the last occurrence of a method; removing one that is not there does nothing.
notify -= Sms;
notify -= Whatsapp;
Console.WriteLine($"after -= Sms and -= Whatsapp: {notify.GetInvocationList().Length} targets");

// A Func with two targets runs both and returns the last one's result.
Func<int, int> score = n => n + 1;
score += n => n * 10;
Console.WriteLine($"score(5) returns {score(5)}");

// The middle target throws, so the third one never runs.
Action<string> fragile = Sms;
fragile += FailingEmail;
fragile += Push;
try
{
    fragile("Order 4520 shipped");
}
catch (InvalidOperationException e)
{
    Console.WriteLine($"stopped by: {e.Message}");
}

static void Sms(string text) => Console.WriteLine($"  SMS:   {text}");

static void Email(string text) => Console.WriteLine($"  email: {text}");

static void Push(string text) => Console.WriteLine($"  push:  {text}");

static void Whatsapp(string text) => Console.WriteLine($"  WhatsApp: {text}");

static void FailingEmail(string text) => throw new InvalidOperationException("the mail server refused the message");

notify has 3 targets
  SMS:   Order 4519 shipped
  email: Order 4519 shipped
  push:  Order 4519 shipped
after one more +=: notify has 4, before still has 3
after -= Sms and -= Whatsapp: 3 targets
score(5) returns 50
  SMS:   Order 4520 shipped
stopped by: the mail server refused the message

// Heap bytes for 1,000 calls that each pass a delegate. Each measurement calls once before it reads the counter, so
// the runtime's one-time work does not show.
using System.Runtime.CompilerServices;

var shop = new Shop();
Func<decimal, decimal> stored = shop.Festival;

Console.WriteLine($"Heap bytes per call, over {Measure.Calls} calls:");
Console.WriteLine($"  a static method group               {Measure.Bytes(() => Pricing.Apply(100m, Rules.Festival)) / Measure.Calls,4}");
Console.WriteLine($"  a lambda that uses only its input   {Measure.Bytes(() => Pricing.Apply(100m, amount => amount - 10m)) / Measure.Calls,4}");
Console.WriteLine($"  an instance method group            {shop.GroupBytes() / Measure.Calls,4}");
Console.WriteLine($"  a lambda that calls an instance one {shop.LambdaBytes() / Measure.Calls,4}");
Console.WriteLine($"  a delegate made once, outside       {Measure.Bytes(() => Pricing.Apply(100m, stored)) / Measure.Calls,4}");

// A delegate variable with no method in it is null. ?.Invoke reads it once and calls it only when it is not null.
Action<string>? onSaved = null;
onSaved?.Invoke("draft 1");
Console.WriteLine($"?.Invoke on null: nothing ran, onSaved is {(onSaved is null ? "null" : "set")}");
try
{
    onSaved!("draft 1");
}
catch (NullReferenceException)
{
    Console.WriteLine("calling null directly: NullReferenceException");
}

onSaved += text => Console.WriteLine($"saved {text}");
onSaved?.Invoke("draft 2");

static class Pricing
{
    public static decimal Apply(decimal amount, Func<decimal, decimal> rule) => rule(amount);
}

static class Rules
{
    public static decimal Festival(decimal amount) => amount * 90 / 100;
}

static class Measure
{
    public const int Calls = 1000;

    // Runs `pass` once to warm up, then Calls times, and returns the heap bytes the Calls passes allocated. The
    // lambda that wraps each pass is made once, so only what happens inside a pass is counted.
    [MethodImpl(MethodImplOptions.AggressiveOptimization)]
    public static long Bytes(Action pass)
    {
        pass();
        long start = GC.GetAllocatedBytesForCurrentThread();
        for (int i = 0; i < Calls; i++)
        {
            pass();
        }

        return GC.GetAllocatedBytesForCurrentThread() - start;
    }
}

class Shop
{
    public decimal Festival(decimal amount) => amount * 90 / 100;

    // shop.Festival as a method group: each pass converts it into a new delegate that holds this shop.
    public long GroupBytes() => Measure.Bytes(() => Pricing.Apply(100m, Festival));

    // A lambda that calls an instance method uses this, so it cannot be cached either.
    public long LambdaBytes() => Measure.Bytes(() => Pricing.Apply(100m, amount => Festival(amount)));
}

Heap bytes per call, over 1000 calls:
  a static method group                  0
  a lambda that uses only its input      0
  an instance method group              64
  a lambda that calls an instance one   64
  a delegate made once, outside          0
?.Invoke on null: nothing ran, onSaved is null
calling null directly: NullReferenceException
saved draft 2

// Practice: write Retries.Retry and Pipelines.Pipeline, then run this file until all ten checks pass. What each method
// must do is in the comment above it. The order numbers and texts are made up for this exercise.
(string Check, Func<string> Run, string Expected)[] checks =
[
    ("succeeds on the first attempt", () => RetryWith(failures: 0, maxAttempts: 3), "attempt 1 succeeded; retried after none"),
    ("succeeds on the third attempt", () => RetryWith(failures: 2, maxAttempts: 3), "attempt 3 succeeded; retried after 1, 2"),
    ("gives up after maxAttempts", () => RetryWith(failures: 9, maxAttempts: 3), "no attempt succeeded; retried after 1, 2"),
    ("a single attempt allowed", () => RetryWith(failures: 9, maxAttempts: 1), "no attempt succeeded; retried after none"),
    ("maxAttempts of 0", () => Outcome(() => Retries.Retry(_ => true, 0, _ => { }).ToString()), "throws ArgumentOutOfRangeException"),
    ("an exception is not retried", ThrowingAttempt, "throws InvalidOperationException after 1 call"),
    ("steps run in order", () => Pipelines.Pipeline(s => s.Trim(), s => s.ToUpperInvariant())("  upi ref 77 "), "UPI REF 77"),
    ("the order of the steps matters", () => Pipelines.Pipeline(s => s + ".", s => s.ToUpperInvariant(), s => $"[{s}]")("paid"), "[PAID.]"),
    ("no steps give back the input", () => Pipelines.Pipeline()("unchanged"), "unchanged"),
    ("each call runs the steps again", CountedPipeline, "2 calls ran 4 steps"),
];

int passed = 0;
foreach (var (check, run, expected) in checks)
{
    string got = Outcome(run);
    bool ok = got == expected;
    if (ok)
    {
        passed++;
    }

    Console.WriteLine(ok ? $"{check}: ok" : $"{check}: FAIL, {got} instead of {expected}");
}

Console.WriteLine($"{passed} of {checks.Length} checks pass");
return passed == checks.Length ? 0 : 1;

// An attempt that fails the first `failures` times, and a log of the retries Retry reports.
static string RetryWith(int failures, int maxAttempts)
{
    var retried = new List<int>();
    int result = Retries.Retry(attempt => attempt > failures, maxAttempts, failed => retried.Add(failed));
    string outcome = result == 0 ? "no attempt succeeded" : $"attempt {result} succeeded";
    return $"{outcome}; retried after {(retried.Count == 0 ? "none" : string.Join(", ", retried))}";
}

static string ThrowingAttempt()
{
    int calls = 0;
    string outcome = Outcome(() => Retries.Retry(_ => { calls++; throw new InvalidOperationException("the bank is down"); }, 3, _ => { }).ToString());
    return $"{outcome} after {calls} call{(calls == 1 ? "" : "s")}";
}

static string CountedPipeline()
{
    int steps = 0;
    Func<string, string> pipeline = Pipelines.Pipeline(s => { steps++; return s.Trim(); }, s => { steps++; return s.ToLowerInvariant(); });
    pipeline(" A ");
    pipeline(" B ");
    return $"2 calls ran {steps} steps";
}

static string Outcome(Func<string> run)
{
    try
    {
        return run();
    }
    catch (Exception e)
    {
        return $"throws {e.GetType().Name}";
    }
}

static class Retries
{
    // Calls attempt(1), attempt(2) and so on, until a call returns true or maxAttempts calls have returned false.
    // Before each new try it calls onRetry with the number of the attempt that just failed. Returns the number of the
    // attempt that succeeded, or 0 when none did. An exception thrown by attempt is not a failed attempt: let it go
    // to the caller, without another try. maxAttempts below 1 throws ArgumentOutOfRangeException.
    public static int Retry(Func<int, bool> attempt, int maxAttempts, Action<int> onRetry)
    {
        throw new NotImplementedException();
    }
}

static class Pipelines
{
    // Returns one function that passes its input through every step, in the order given, and returns what the last
    // step returned. With no steps, it returns its input unchanged. The steps run again on every call.
    public static Func<string, string> Pipeline(params Func<string, string>[] steps)
    {
        throw new NotImplementedException();
    }
}

succeeds on the first attempt: FAIL, throws NotImplementedException instead of attempt 1 succeeded; retried after none
succeeds on the third attempt: FAIL, throws NotImplementedException instead of attempt 3 succeeded; retried after 1, 2
gives up after maxAttempts: FAIL, throws NotImplementedException instead of no attempt succeeded; retried after 1, 2
a single attempt allowed: FAIL, throws NotImplementedException instead of no attempt succeeded; retried after none
maxAttempts of 0: FAIL, throws NotImplementedException instead of throws ArgumentOutOfRangeException
an exception is not retried: FAIL, throws NotImplementedException after 0 calls instead of throws InvalidOperationException after 1 call
steps run in order: FAIL, throws NotImplementedException instead of UPI REF 77
the order of the steps matters: FAIL, throws NotImplementedException instead of [PAID.]
no steps give back the input: FAIL, throws NotImplementedException instead of unchanged
each call runs the steps again: FAIL, throws NotImplementedException instead of 2 calls ran 4 steps
0 of 10 checks pass