Behavioral Design Patterns

// The Handler: declares the interface + the "pass it on" boilerplate.
// We use an abstract class (not a pure interface) because the
// do-next logic is shared by every handler — no point duplicating it.
public abstract class HandlerChain
{
    private HandlerChain? _next;

    // Fluent linking: returns the handler we just attached so
    // calls can be chained: a.SetNext(b).SetNext(c);
    public HandlerChain SetNext(HandlerChain next)
    {
        _next = next;
        return next;
    }

    // Each concrete handler implements this.
    public abstract string AddHeader(string input);

    // Shared: forward to the next link, or end the chain.
    protected string DoNext(string input)
        => _next is null ? input : _next.AddHeader(input);
}

public class AuthenticationHeader : HandlerChain
{
    private readonly string _token;
    public AuthenticationHeader(string token) => _token = token;

    public override string AddHeader(string input)
    {
        var h = $"{input}\nAuthorization: {_token}";
        return DoNext(h);                // process, then pass on
    }
}

public class ContentTypeHeader : HandlerChain
{
    private readonly string _contentType;
    public ContentTypeHeader(string ct) => _contentType = ct;

    public override string AddHeader(string input)
        => DoNext($"{input}\nContent-Type: {_contentType}");
}

public class BodyPayloadHeader : HandlerChain
{
    private readonly string _body;
    public BodyPayloadHeader(string body) => _body = body;

    public override string AddHeader(string input)
        => DoNext($"{input}\n{_body}");
}

var auth = new AuthenticationHeader("123456");
auth.SetNext(new ContentTypeHeader("application/json"))
    .SetNext(new BodyPayloadHeader("{ \"user\": \"john\" }"));

// Enter at the top of the chain:
string message = auth.AddHeader("POST /orders HTTP/1.1");
Console.WriteLine(message);

// Enter partway down — auth is simply skipped:
// contentTypeHeader.AddHeader("GET /health HTTP/1.1");

// The Command interface: one method to run, one to reverse.
public interface ICommand
{
    void Execute();
    void Undo();
}

// The Receiver: holds the real business logic / state.
public class TextDocument
{
    public string Text { get; private set; } = "";
    public void Append(string s) => Text += s;
    public void RemoveLast(int count) =>
        Text = Text[..Math.Max(0, Text.Length - count)];
}

// A Concrete Command remembers what it did so it can undo it.
public class TypeCommand : ICommand
{
    private readonly TextDocument _doc;
    private readonly string _text;

    public TypeCommand(TextDocument doc, string text)
    {
        _doc = doc;
        _text = text;
    }

    public void Execute() => _doc.Append(_text);
    public void Undo()    => _doc.RemoveLast(_text.Length);
}

public class Editor
{
    private readonly Stack<ICommand> _done = new();
    private readonly Stack<ICommand> _undone = new();

    public void Run(ICommand cmd)
    {
        cmd.Execute();
        _done.Push(cmd);
        _undone.Clear();      // new action invalidates redo
    }

    public void Undo()
    {
        if (_done.Count == 0) return;
        var cmd = _done.Pop();
        cmd.Undo();
        _undone.Push(cmd);
    }

    public void Redo()
    {
        if (_undone.Count == 0) return;
        var cmd = _undone.Pop();
        cmd.Execute();
        _done.Push(cmd);
    }
}

// The Iterator interface: the two questions every traversal answers.
public interface IIterator<T>
{
    bool HasNext();
    T Next();
}

// The Collection interface: hands out iterators, hides its guts.
public interface IWordCollection
{
    IIterator<string> GetIterator();
    IIterator<string> GetReverseIterator();
}

public class AlphabeticalIterator : IIterator<string>
{
    private readonly List<string> _items;
    private readonly bool _reverse;
    private int _pos;

    public AlphabeticalIterator(IEnumerable<string> words, bool reverse = false)
    {
        _items = words.OrderBy(w => w).ToList();
        _reverse = reverse;
        _pos = reverse ? _items.Count - 1 : 0;
    }

    public bool HasNext() => _reverse ? _pos >= 0 : _pos < _items.Count;

    public string Next()
    {
        var value = _items[_pos];
        _pos += _reverse ? -1 : 1;   // iterator owns the cursor
        return value;
    }
}

public class WordCollection : IWordCollection
{
    private readonly List<string> _words;
    public WordCollection(IEnumerable<string> words) => _words = words.ToList();

    public IIterator<string> GetIterator() => new AlphabeticalIterator(_words);
    public IIterator<string> GetReverseIterator() => new AlphabeticalIterator(_words, true);
}

// In C# you rarely hand-roll an iterator: IEnumerable<T> is the
// aggregate, IEnumerator<T> is the Iterator, and `yield return` writes it for you.
public class Playlist : IEnumerable<string>
{
    private readonly List<string> _songs = new();
    public void Add(string s) => _songs.Add(s);

    public IEnumerator<string> GetEnumerator()
    {
        foreach (var song in _songs)
            yield return song;      // compiler builds the iterator
    }
    System.Collections.IEnumerator
        System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();
}

// Client — never sees the List inside:
foreach (var song in new Playlist()) Console.WriteLine(song);

public interface IChatMediator
{
    void Register(ChatUser user);
    void Send(string message, ChatUser sender);
}

// Concrete Mediator: knows all users, does the routing.
public class ChatRoom : IChatMediator
{
    private readonly List<ChatUser> _users = new();

    public void Register(ChatUser user)
    {
        _users.Add(user);
        user.SetMediator(this);
    }

    public void Send(string message, ChatUser sender)
    {
        foreach (var u in _users)
            if (u != sender)          // don't echo to the sender
                u.Receive(message, sender.Name);
    }
}

// A Colleague talks ONLY to the mediator — never to other users.
public class ChatUser
{
    public string Name { get; }
    private IChatMediator? _mediator;
    public ChatUser(string name) => Name = name;

    public void SetMediator(IChatMediator m) => _mediator = m;

    public void Send(string message)
    {
        Console.WriteLine($"{Name} sends: {message}");
        _mediator?.Send(message, this);   // hand it to the hub
    }

    public void Receive(string message, string from)
        => Console.WriteLine($"  {Name} got from {from}: {message}");
}

var room = new ChatRoom();
var alice = new ChatUser("Alice");
var bob   = new ChatUser("Bob");
var carol = new ChatUser("Carol");

room.Register(alice);
room.Register(bob);
room.Register(carol);

carol.Send("Hi everyone!");  // routed to Alice & Bob via the room
// Carol has no reference to Alice or Bob at all.

// The Memento: an immutable snapshot. `internal` keeps Content hidden
// from callers in OTHER assemblies. Be honest about what that buys you:
// `internal` means EVERY type in THIS assembly can read Content, not
// only the Originator. It's a pragmatic guard — fine when the Editor
// lives in its own assembly — not true originator-only access. For that,
// use the private-nested-class variant shown below.
public sealed class EditorMemento
{
    // Internal → readable by any code in the SAME assembly.
    internal string Content { get; }
    public DateTime SavedAt { get; }   // metadata IS public

    internal EditorMemento(string content)
    {
        Content = content;
        SavedAt = DateTime.Now;
    }
}

public class Editor
{
    private string _content = "";      // stays private!
    public void Type(string s) => _content += s;
    public string Read() => _content;

    // Make a snapshot of my own private state.
    public EditorMemento Save() => new(_content);

    // Restore from a snapshot I previously produced.
    public void Restore(EditorMemento m) => _content = m.Content;
}

// The Caretaker: keeps mementos but never looks inside them.
public class History
{
    private readonly Stack<EditorMemento> _snapshots = new();
    public void Push(EditorMemento m) => _snapshots.Push(m);
    public EditorMemento? Pop() => _snapshots.Count > 0 ? _snapshots.Pop() : null;
}

var editor = new Editor();
var history = new History();

editor.Type("Hello");
history.Push(editor.Save());   // checkpoint
editor.Type(", world");
Console.WriteLine(editor.Read());   // Hello, world

var snap = history.Pop();
if (snap is not null) editor.Restore(snap);
Console.WriteLine(editor.Read());   // Hello   (undone)

// The Observer interface: the notification contract.
public interface IEventListener
{
    void Update(string eventType, string file);
}

// The Subject / Publisher: manages subscriptions and notifies.
public class EventManager
{
    private readonly Dictionary<string, List<IEventListener>> _listeners = new();

    public void Subscribe(string eventType, IEventListener l)
    {
        if (!_listeners.ContainsKey(eventType))
            _listeners[eventType] = new();
        _listeners[eventType].Add(l);
    }

    public void Unsubscribe(string eventType, IEventListener l)
        => _listeners.GetValueOrDefault(eventType)?.Remove(l);

    public void Notify(string eventType, string file)
    {
        if (_listeners.TryGetValue(eventType, out var ls))
            foreach (var l in ls) l.Update(eventType, file);
    }
}

public class Editor          // owns a publisher
{
    public EventManager Events { get; } = new();
    private string _file = "";

    public void OpenFile(string file)
    {
        _file = file;
        Events.Notify("open", file);   // broadcast
    }
    public void SaveFile() => Events.Notify("save", _file);
}

public class EmailAlertListener : IEventListener
{
    private readonly string _email;
    public EmailAlertListener(string email) => _email = email;
    public void Update(string type, string file)
        => Console.WriteLine($"Email {_email}: '{type}' on {file}");
}

public class LogListener : IEventListener
{
    public void Update(string type, string file)
        => Console.WriteLine($"Log: '{type}' on {file}");
}

var editor = new Editor();
var email = new EmailAlertListener("boss@corp.com");
var log   = new LogListener();

editor.Events.Subscribe("open", log);
editor.Events.Subscribe("save", log);
editor.Events.Subscribe("save", email);   // email only cares about saves

editor.OpenFile("report.txt");  // -> log only
editor.SaveFile();              // -> log AND email

editor.Events.Unsubscribe("save", email); // boss stops caring
editor.SaveFile();             // -> log only again

// The State interface: the state-dependent actions.
public interface IGameState
{
    void OnStart(Game game);
    void OnPause(Game game);
    void OnEnd(Game game);
    string Name { get; }
}

// The Context: delegates all behavior to its current state.
public class Game
{
    public IGameState State { get; private set; }
    public Game() => State = new WelcomeState();

    public void SetState(IGameState s)
    {
        Console.WriteLine($"  → transition to {s.Name}");
        State = s;
    }

    // The context just forwards — no conditionals.
    public void Start() => State.OnStart(this);
    public void Pause() => State.OnPause(this);
    public void End()   => State.OnEnd(this);
}

public class WelcomeState : IGameState
{
    public string Name => "Welcome";
    public void OnStart(Game g) => g.SetState(new PlayingState());
    public void OnPause(Game g) => Console.WriteLine("Can't pause on welcome screen");
    public void OnEnd(Game g)   => Console.WriteLine("Nothing to end yet");
}

public class PlayingState : IGameState
{
    public string Name => "Playing";
    public void OnStart(Game g) => Console.WriteLine("Already playing");
    public void OnPause(Game g) => g.SetState(new PausedState());
    public void OnEnd(Game g)   => g.SetState(new GameOverState());
}

public class PausedState : IGameState
{
    public string Name => "Paused";
    public void OnStart(Game g) => g.SetState(new PlayingState()); // resume
    public void OnPause(Game g) => Console.WriteLine("Already paused");
    public void OnEnd(Game g)   => g.SetState(new GameOverState());
}

public class GameOverState : IGameState
{
    public string Name => "Game Over";
    public void OnStart(Game g) => g.SetState(new WelcomeState()); // restart
    public void OnPause(Game g) => Console.WriteLine("Game is over");
    public void OnEnd(Game g)   => Console.WriteLine("Game is already over");
}

var game = new Game();          // starts in Welcome
game.Start();                   // Welcome -> Playing
game.Pause();                   // Playing -> Paused
game.Pause();                   // "Already paused" (rejected)
game.Start();                   // Paused -> Playing (resume)
game.End();                     // Playing -> Game Over
game.Start();                   // Game Over -> Welcome (restart)

// The Strategy interface: one method, many algorithms.
public interface IShippingStrategy
{
    decimal Cost(decimal weightKg, decimal distanceKm);
}

// The Context: holds a strategy, delegates the calculation.
public class ShippingCalculator
{
    private IShippingStrategy _strategy;
    public ShippingCalculator(IShippingStrategy s) => _strategy = s;

    // Swap the algorithm at run-time:
    public void SetStrategy(IShippingStrategy s) => _strategy = s;

    public decimal Quote(decimal weight, decimal distance)
        => _strategy.Cost(weight, distance);   // no idea which algorithm
}

public class StandardShipping : IShippingStrategy
{
    public decimal Cost(decimal w, decimal d) => 5m + w * 0.5m + d * 0.02m;
}

public class ExpressShipping : IShippingStrategy
{
    public decimal Cost(decimal w, decimal d) => 12m + w * 1.2m + d * 0.05m;
}

public class DroneShipping : IShippingStrategy
{
    // Different rules entirely — capped distance, flat premium.
    public decimal Cost(decimal w, decimal d)
        => d > 20 ? decimal.MaxValue : 20m + w * 2m;
}

var calc = new ShippingCalculator(new StandardShipping());
Console.WriteLine(calc.Quote(2m, 100m));   // standard

calc.SetStrategy(new ExpressShipping());   // client hot-swaps
Console.WriteLine(calc.Quote(2m, 100m));   // express

calc.SetStrategy(new DroneShipping());
Console.WriteLine(calc.Quote(2m, 5m));     // drone

public abstract class Beverage
{
    // THE TEMPLATE METHOD — the fixed skeleton. Not virtual:
    // subclasses must not change the algorithm's structure.
    public void Prepare()
    {
        BoilWater();          // fixed step (shared)
        Brew();               // varies — abstract
        PourInCup();          // fixed step (shared)
        if (WantsCondiments())  // hook — optional override
            AddCondiments();  // varies — abstract
    }

    // Fixed steps: implemented once here.
    private void BoilWater() => Console.WriteLine("Boiling water");
    private void PourInCup() => Console.WriteLine("Pouring into cup");

    // Variable steps: subclasses MUST implement.
    protected abstract void Brew();
    protected abstract void AddCondiments();

    // A HOOK: default behavior a subclass MAY override.
    protected virtual bool WantsCondiments() => true;
}

public class Tea : Beverage
{
    protected override void Brew()
        => Console.WriteLine("Steeping the tea bag");
    protected override void AddCondiments()
        => Console.WriteLine("Adding lemon");
}

public class Coffee : Beverage
{
    protected override void Brew()
        => Console.WriteLine("Dripping coffee through filter");
    protected override void AddCondiments()
        => Console.WriteLine("Adding sugar and milk");

    // Overrides the hook to skip a step:
    protected override bool WantsCondiments() => false;
}

Beverage tea = new Tea();
tea.Prepare();
// Boiling water / Steeping the tea bag / Pouring / Adding lemon

Console.WriteLine("---");

Beverage coffee = new Coffee();
coffee.Prepare();
// Boiling water / Dripping coffee / Pouring
// (condiments skipped — the hook returned false)

// The Element interface: declares Accept.
public interface IContract
{
    // The parameter is the VISITOR interface. This one line
    // is what makes double dispatch possible.
    T Accept<T>(IReportVisitor<T> visitor);
}

// The Visitor interface: one Visit overload PER concrete element.
public interface IReportVisitor<T>
{
    T Visit(FixedPriceContract c);
    T Visit(TimeAndMaterialsContract c);
    T Visit(SupportContract c);
}

public class FixedPriceContract : IContract
{
    public decimal PricePerYear { get; init; }
    // Accept's ONLY job: bounce to visitor.Visit(this).
    // Inside THIS class, `this` is statically FixedPriceContract,
    // so the correct Visit overload is chosen at compile time.
    public T Accept<T>(IReportVisitor<T> v) => v.Visit(this);
}

public class TimeAndMaterialsContract : IContract
{
    public decimal CostPerHour { get; init; }
    public int Hours { get; init; }
    public T Accept<T>(IReportVisitor<T> v) => v.Visit(this);
}

public class SupportContract : IContract
{
    public decimal CostPerMonth { get; init; }
    public T Accept<T>(IReportVisitor<T> v) => v.Visit(this);
}

// Each concrete visitor is a NEW operation over ALL element types —
// added without touching a single contract class.
public class MonthlyCostVisitor : IReportVisitor<decimal>
{
    public decimal Visit(FixedPriceContract c) => c.PricePerYear / 12;
    public decimal Visit(TimeAndMaterialsContract c) => c.CostPerHour * c.Hours;
    public decimal Visit(SupportContract c) => c.CostPerMonth;
}

public class YearlyCostVisitor : IReportVisitor<decimal>
{
    public decimal Visit(FixedPriceContract c) => c.PricePerYear;
    public decimal Visit(TimeAndMaterialsContract c) => c.CostPerHour * c.Hours;
    public decimal Visit(SupportContract c) => c.CostPerMonth * 12;
}

var contracts = new List<IContract>
{
    new FixedPriceContract { PricePerYear = 12000 },
    new TimeAndMaterialsContract { CostPerHour = 150, Hours = 10 },
    new SupportContract { CostPerMonth = 500 },
};

var monthly = new MonthlyCostVisitor();
decimal total = 0;
foreach (var c in contracts)
    total += c.Accept(monthly);   // double dispatch, per element
Console.WriteLine($"Monthly total: {total}");

// New report type = new visitor, ZERO changes to contract classes:
var yearly = new YearlyCostVisitor();
Console.WriteLine(contracts.Sum(c => c.Accept(yearly)));

// AbstractExpression
public interface IExpression { double Interpret(); }

// Terminal expression: a literal number.
public class Number : IExpression
{
    private readonly double _value;
    public Number(double value) => _value = value;
    public double Interpret() => _value;   // interprets to itself
}

// Non-terminal expressions: combine two sub-expressions.
public class Add : IExpression
{
    private readonly IExpression _l, _r;
    public Add(IExpression l, IExpression r) { _l = l; _r = r; }
    public double Interpret() => _l.Interpret() + _r.Interpret();  // recursion
}

public class Multiply : IExpression
{
    private readonly IExpression _l, _r;
    public Multiply(IExpression l, IExpression r) { _l = l; _r = r; }
    public double Interpret() => _l.Interpret() * _r.Interpret();
}

// Build the AST for "3 + 5 * 2" (5*2 grouped by precedence):
//        Add
//       /   \
//   Number(3) Multiply
//             /      \
//        Number(5)  Number(2)
IExpression tree =
    new Add(
        new Number(3),
        new Multiply(new Number(5), new Number(2)));

Console.WriteLine(tree.Interpret());   // 13

// Each node evaluates its children recursively, leaves first.
// A real client parses text into this tree; the grammar
// lives in the class structure itself.