Classic design patterns in idiomatic C#

// One discount rule, plugged into a checkout two ways: as a delegate and as an interface. Same output.
Order[] orders = [new(800m, IsMember: true), new(1200m, IsMember: false)];

// Strategy as a delegate: the behaviour is a Func<Order, decimal>, here a lambda.
Func<Order, decimal> memberDiscount = order => order.IsMember ? order.Subtotal * 0.10m : 0m;
var byDelegate = new Checkout(memberDiscount);

// Strategy as an interface: the behaviour is an object, with a name and settings of its own.
var byInterface = new RuleCheckout(new MemberDiscount(percent: 10));

foreach (Order order in orders)
{
    Console.WriteLine($"Rs {order.Subtotal:F2}: delegate Rs {byDelegate.Total(order):F2}, interface Rs {byInterface.Total(order):F2}");
}

Console.WriteLine(byInterface.Explain(orders[0]));

record Order(decimal Subtotal, bool IsMember);

class Checkout(Func<Order, decimal> discount)
{
    public decimal Total(Order order) => order.Subtotal - discount(order);
}

interface IDiscountRule
{
    string Name { get; }

    decimal For(Order order);
}

class MemberDiscount(int percent) : IDiscountRule
{
    public string Name => $"member {percent} %";

    public decimal For(Order order) => order.IsMember ? order.Subtotal * percent / 100m : 0m;
}

class RuleCheckout(IDiscountRule rule)
{
    public decimal Total(Order order) => order.Subtotal - rule.For(order);

    public string Explain(Order order) => $"{rule.Name}: Rs {rule.For(order):F2} off";
}

Rs 800.00: delegate Rs 720.00, interface Rs 720.00
Rs 1200.00: delegate Rs 1200.00, interface Rs 1200.00
member 10 %: Rs 80.00 off

// Stream decorators: GZipStream wraps another stream and compresses what passes through it, and the code that
// writes sees only a Stream. The text is 200 copies of one invoice line.
using System.IO.Compression;
using System.Text;

string text = string.Concat(Enumerable.Repeat("INV-1001, Rice 5 kg, 320.00\n", 200));
byte[] original = Encoding.UTF8.GetBytes(text);

using var compressed = new MemoryStream();
using (var gzip = new GZipStream(compressed, CompressionLevel.Optimal, leaveOpen: true))
{
    gzip.Write(original);
}

Console.WriteLine($"original:   {original.Length} bytes");
Console.WriteLine($"compressed: {compressed.Length} bytes");

// Reading back: another decorator, then a StreamReader that turns bytes into text.
compressed.Position = 0;
using var unzip = new GZipStream(compressed, CompressionMode.Decompress);
using var reader = new StreamReader(unzip, Encoding.UTF8);
Console.WriteLine($"round trip equal: {reader.ReadToEnd() == text}");

original:   5600 bytes
compressed: 109 bytes
round trip equal: True

// Practice: replace the nested ifs of LegacyPricing with three IDiscount strategies, added up by AllDiscounts, and a
// decorator that caps what it wraps, composed in Discounts.Standard(). The rules and amounts are made up for this
// exercise. Run this file until all eight checks pass.
using System.Globalization;

Order[] orders =
[
    new(500m, Items: 2, IsMember: false, Festival: false),
    new(800m, Items: 3, IsMember: true, Festival: false),
    new(1200m, Items: 4, IsMember: false, Festival: true),
    new(900m, Items: 4, IsMember: false, Festival: true),
    new(600m, Items: 12, IsMember: false, Festival: false),
    new(2000m, Items: 15, IsMember: true, Festival: true),
    new(1000m, Items: 10, IsMember: true, Festival: true),
];
string[] names = ["no discount", "member 10 %", "festival, Rs 1,000 or more", "festival below Rs 1,000", "bulk, 10 items or more", "all three", "the 25 % cap"];
string[] expected = ["500.00", "720.00", "1050.00", "900.00", "570.00", "1550.00", "750.00"];

var checks = new List<(string Check, Func<string> Run, string Expected)>();
for (int i = 0; i < orders.Length; i++)
{
    Order order = orders[i];
    checks.Add((names[i], () => Money(new PricingEngine(Discounts.Standard()).Total(order)), expected[i]));
}

checks.Add(("same totals as LegacyPricing", () => orders.All(o => new PricingEngine(Discounts.Standard()).Total(o) == LegacyPricing.Total(o)).ToString(), "True"));

int passed = 0;
foreach (var (check, run, want) in checks)
{
    string got;
    try
    {
        got = run();
    }
    catch (Exception e)
    {
        got = $"throws {e.GetType().Name}";
    }

    bool ok = got == want;
    if (ok)
    {
        passed++;
    }

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

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

static string Money(decimal amount) => amount.ToString("F2", CultureInfo.InvariantCulture);

record Order(decimal Subtotal, int Items, bool IsMember, bool Festival);

// The old engine: right answers, but every new discount means another branch in this one method.
static class LegacyPricing
{
    public static decimal Total(Order order)
    {
        decimal discount = 0m;
        if (order.IsMember)
        {
            discount += order.Subtotal * 10 / 100;
        }

        if (order.Festival)
        {
            if (order.Subtotal >= 1000m)
            {
                discount += 150m;
            }
        }

        if (order.Items >= 10)
        {
            discount += order.Subtotal * 5 / 100;
        }

        if (discount > order.Subtotal * 25 / 100)
        {
            discount = order.Subtotal * 25 / 100;
        }

        return order.Subtotal - discount;
    }
}

interface IDiscount
{
    decimal For(Order order);
}

class PricingEngine(IDiscount discount)
{
    public decimal Total(Order order) => order.Subtotal - discount.For(order);
}

// Members get 10 % off.
class MemberDiscount : IDiscount
{
    public decimal For(Order order) => throw new NotImplementedException();
}

// During the festival, Rs 150 off orders of Rs 1,000 or more.
class FestivalDiscount : IDiscount
{
    public decimal For(Order order) => throw new NotImplementedException();
}

// 5 % off orders of 10 items or more.
class BulkDiscount : IDiscount
{
    public decimal For(Order order) => throw new NotImplementedException();
}

// Given: an IDiscount that adds up the discounts it holds.
class AllDiscounts(params IDiscount[] discounts) : IDiscount
{
    public decimal For(Order order) => discounts.Sum(discount => discount.For(order));
}

// The decorator: an IDiscount that wraps one IDiscount and never gives more than maxShare of the subtotal.
class CappedDiscount(decimal maxShare, IDiscount inner) : IDiscount
{
    public decimal For(Order order) => throw new NotImplementedException();
}

// The standard discounts: the three strategies, added up, then capped at 25 % of the subtotal.
static class Discounts
{
    public static IDiscount Standard() => throw new NotImplementedException();
}

no discount: FAIL, throws NotImplementedException instead of 500.00
member 10 %: FAIL, throws NotImplementedException instead of 720.00
festival, Rs 1,000 or more: FAIL, throws NotImplementedException instead of 1050.00
festival below Rs 1,000: FAIL, throws NotImplementedException instead of 900.00
bulk, 10 items or more: FAIL, throws NotImplementedException instead of 570.00
all three: FAIL, throws NotImplementedException instead of 1550.00
the 25 % cap: FAIL, throws NotImplementedException instead of 750.00
same totals as LegacyPricing: FAIL, throws NotImplementedException instead of True
0 of 8 checks pass