23 种设计模式学习实践（C# 实现）

public sealed class AppConfig
{
    private static readonly Lazy<AppConfig> _instance = new(
        () => new AppConfig(),
        LazyThreadSafetyMode.ExecutionAndPublication);

    public static AppConfig Instance => _instance.Value;

    // 私有构造函数：挡住外部 new
    private AppConfig()
    {
        LoadFromFile("appsettings.json");
    }

    public string ConnectionString { get; private set; } = string.Empty;

    private void LoadFromFile(string path)
    {
        // 省略实际读取逻辑
        ConnectionString = "Server=localhost;Database=Demo;";
    }
}

// Program.cs
builder.Services.AddSingleton<IAppConfigService, AppConfigService>();
builder.Services.AddSingleton<IOrderRepository, OrderRepository>();   // 无状态、线程安全才可单例
builder.Services.AddScoped<IUnitOfWork, UnitOfWork>();                // 每请求一个实例

// 产品接口
public interface IExportFile
{
    void Write(string content);
}

public class PdfExport : IExportFile
{
    public void Write(string content) => Console.WriteLine($"写入 PDF：{content}");
}

public class ExcelExport : IExportFile
{
    public void Write(string content) => Console.WriteLine($"写入 Excel：{content}");
}

// 工厂：把「创建」这一步留给子类
public abstract class ExportService
{
    protected abstract IExportFile CreateExportFile();

    public void Export(string content)
    {
        var file = CreateExportFile();   // 这里不出现任何具体类型
        file.Write(content);
    }
}

public class PdfExportService : ExportService
{
    protected override IExportFile CreateExportFile() => new PdfExport();
}

public class ExcelExportService : ExportService
{
    protected override IExportFile CreateExportFile() => new ExcelExport();
}

// 产品族 A：按钮
public interface IButton { void Render(); }
// 产品族 B：文本框
public interface ITextBox { void Render(); }

// 抽象工厂：负责生产一整套
public interface IUiFactory
{
    IButton CreateButton();
    ITextBox CreateTextBox();
}

public class LightButton : IButton { public void Render() => Console.WriteLine("浅色按钮"); }
public class LightTextBox : ITextBox { public void Render() => Console.WriteLine("浅色文本框"); }

public class DarkButton : IButton { public void Render() => Console.WriteLine("深色按钮"); }
public class DarkTextBox : ITextBox { public void Render() => Console.WriteLine("深色文本框"); }

public class LightThemeFactory : IUiFactory
{
    public IButton CreateButton() => new LightButton();
    public ITextBox CreateTextBox() => new LightTextBox();
}

public class DarkThemeFactory : IUiFactory
{
    public IButton CreateButton() => new DarkButton();
    public ITextBox CreateTextBox() => new DarkTextBox();
}

public sealed class HttpRequest
{
    public string Url { get; init; } = string.Empty;
    public string Method { get; init; } = "GET";
    public IReadOnlyDictionary<string, string> Headers { get; init; }
        = new Dictionary<string, string>();
    public string? Body { get; init; }
    public TimeSpan Timeout { get; init; } = TimeSpan.FromSeconds(30);

    public override string ToString()
        => $"{Method} {Url}（{Headers.Count} 个请求头，超时 {Timeout.TotalSeconds}s）";
}

public class HttpRequestBuilder
{
    private string _url = string.Empty;
    private string _method = "GET";
    private readonly Dictionary<string, string> _headers = new();
    private string? _body;
    private TimeSpan _timeout = TimeSpan.FromSeconds(30);

    public HttpRequestBuilder To(string url)
    {
        if (!Uri.TryCreate(url, UriKind.Absolute, out _))
            throw new ArgumentException($"URL 不合法：{url}", nameof(url));
        _url = url;
        return this;                       // 链式调用
    }

    public HttpRequestBuilder WithMethod(string method)
    {
        _method = method.ToUpperInvariant();
        return this;
    }

    public HttpRequestBuilder WithHeader(string key, string value)
    {
        _headers[key] = value;
        return this;
    }

    public HttpRequestBuilder WithBody(string body)
    {
        _body = body;
        return this;
    }

    public HttpRequestBuilder WithTimeout(TimeSpan timeout)
    {
        if (timeout <= TimeSpan.Zero)
            throw new ArgumentOutOfRangeException(nameof(timeout), "超时必须为正数");
        _timeout = timeout;
        return this;
    }

    public HttpRequest Build()
    {
        // 跨字段约束在 Build 时统一校验
        if (_method is "POST" or "PUT" && _body is null)
            throw new InvalidOperationException($"{_method} 请求必须提供 Body");

        return new HttpRequest
        {
            Url = _url,
            Method = _method,
            Headers = new Dictionary<string, string>(_headers),
            Body = _body,
            Timeout = _timeout
        };
    }
}

// 使用
var request = new HttpRequestBuilder()
    .To("https://api.example.com/orders")
    .WithMethod("POST")
    .WithHeader("Authorization", "Bearer xxx")
    .WithBody("""{"id":1}""")
    .WithTimeout(TimeSpan.FromSeconds(10))
    .Build();

public class DocumentTemplate
{
    public string Title { get; set; } = string.Empty;
    public List<string> Sections { get; set; } = new();
    public Dictionary<string, string> Metadata { get; set; } = new();

    // 浅拷贝：引用类型字段仍然指向同一份数据
    public DocumentTemplate ShallowCopy() => (DocumentTemplate)MemberwiseClone();

    // 深拷贝：引用类型逐层复制，互不影响
    public DocumentTemplate DeepCopy() => new()
    {
        Title = Title,
        Sections = new List<string>(Sections),
        Metadata = new Dictionary<string, string>(Metadata)
    };
}

// 使用
var template = new DocumentTemplate
{
    Title = "季度报告",
    Sections = { "概述", "数据", "结论" }
};

var copy = template.DeepCopy();
copy.Sections.Add("附录");        // 不影响 template
Console.WriteLine(template.Sections.Count);   // 3

// 本方系统统一使用的支付接口
public interface IPaymentGateway
{
    void Pay(decimal amount, string orderNo);
}

// 第三方老旧 SDK：接口签名完全对不上，且不能修改（第三方包）
public class LegacyAlipaySdk
{
    public void MakePayment(string moneyInYuan, string tradeNo)
    {
        Console.WriteLine($"老 SDK 支付 {moneyInYuan} 元，交易号 {tradeNo}");
    }
}

// 对象适配器：用组合持有被适配者，这是推荐做法
public class AlipayAdapter : IPaymentGateway
{
    private readonly LegacyAlipaySdk _sdk = new();

    public void Pay(decimal amount, string orderNo)
    {
        // 接口转换 + 单位换算：本系统用 decimal 元，SDK 要两位小数字符串
        _sdk.MakePayment(amount.ToString("F2"), orderNo);
    }
}

// 维度一：形状（抽象部分）
public abstract class Shape
{
    protected readonly IRenderer Renderer;      // 桥：持有实现维度的引用

    protected Shape(IRenderer renderer) => Renderer = renderer;

    public abstract void Draw();
}

// 维度二：渲染方式（实现部分）
public interface IRenderer
{
    void RenderCircle(double radius);
    void RenderSquare(double side);
}

public class VectorRenderer : IRenderer
{
    public void RenderCircle(double radius) => Console.WriteLine($"矢量绘制圆，半径 {radius}");
    public void RenderSquare(double side) => Console.WriteLine($"矢量绘制方形，边长 {side}");
}

public class RasterRenderer : IRenderer
{
    public void RenderCircle(double radius) => Console.WriteLine($"像素绘制圆，半径 {radius}");
    public void RenderSquare(double side) => Console.WriteLine($"像素绘制方形，边长 {side}");
}

public class Circle : Shape
{
    private readonly double _radius;
    public Circle(IRenderer renderer, double radius) : base(renderer) => _radius = radius;

    public override void Draw() => Renderer.RenderCircle(_radius);
}

public class Square : Shape
{
    private readonly double _side;
    public Square(IRenderer renderer, double side) : base(renderer) => _side = side;

    public override void Draw() => Renderer.RenderSquare(_side);
}

// 使用：2 种形状 + 2 种渲染 = 4 个类；继承方案需要 2×2=4 个具体类，
// 而抽象/实现各自再增加一种时，桥接只需加 1 个类，继承方案要加 N 个
new Circle(new VectorRenderer(), 5).Draw();
new Square(new RasterRenderer(), 3).Draw();

public abstract class FileSystemNode
{
    protected FileSystemNode(string name) => Name = name;
    public string Name { get; }

    public abstract long GetSize();
    public virtual void Print(string indent = "")
        => Console.WriteLine($"{indent}{Name}（{GetSize()} 字节）");
}

public class FileNode : FileSystemNode
{
    private readonly long _size;
    public FileNode(string name, long size) : base(name) => _size = size;

    public override long GetSize() => _size;
}

public class DirectoryNode : FileSystemNode
{
    private readonly List<FileSystemNode> _children = new();

    public DirectoryNode(string name) : base(name) { }

    public DirectoryNode Add(FileSystemNode node)
    {
        _children.Add(node);
        return this;                       // 链式添加，方便构造树
    }

    public override long GetSize() => _children.Sum(c => c.GetSize());

    public override void Print(string indent = "")
    {
        base.Print(indent);                // 目录自身
        foreach (var child in _children)
            child.Print(indent + "  ");    // 递归下去，叶子节点会自然终止
    }
}

// 使用
var root = new DirectoryNode("src")
    .Add(new FileNode("Program.cs", 2048))
    .Add(new DirectoryNode("Models")
        .Add(new FileNode("User.cs", 512))
        .Add(new FileNode("Order.cs", 1024)));

Console.WriteLine(root.GetSize());   // 3584，递归聚合
root.Print();

public interface IDataStore
{
    void Write(string data);
    string Read();
}

public class MemoryStore : IDataStore
{
    private string _data = string.Empty;
    public void Write(string data) => _data = data;
    public string Read() => _data;
}

// 装饰器基类：实现同一接口 + 持有同接口引用
public abstract class StoreDecorator : IDataStore
{
    protected readonly IDataStore Inner;
    protected StoreDecorator(IDataStore inner) => Inner = inner;

    public virtual void Write(string data) => Inner.Write(data);
    public virtual string Read() => Inner.Read();
}

public class CompressionDecorator : StoreDecorator
{
    public CompressionDecorator(IDataStore inner) : base(inner) { }

    public override void Write(string data)
    {
        Console.WriteLine("[压缩] 写入前压缩");
        Inner.Write($"<compressed>{data}</compressed>");
    }

    public override string Read()
    {
        var raw = Inner.Read();
        Console.WriteLine("[压缩] 读取后解压");
        return raw.Replace("<compressed>", "").Replace("</compressed>", "");
    }
}

public class EncryptionDecorator : StoreDecorator
{
    public EncryptionDecorator(IDataStore inner) : base(inner) { }

    public override void Write(string data)
    {
        Console.WriteLine("[加密] 写入前加密");
        Inner.Write(Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(data)));
    }

    public override string Read()
    {
        var raw = Inner.Read();
        Console.WriteLine("[加密] 读取后解密");
        return System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(raw));
    }
}

// 使用：运行时任意叠加，顺序即语义
IDataStore store = new EncryptionDecorator(new CompressionDecorator(new MemoryStore()));
store.Write("hello");
Console.WriteLine(store.Read());     // hello

// 子系统：三个各自独立、协作顺序有讲究的服务
public class InventoryService
{
    public bool Check(string sku, int qty)
    {
        Console.WriteLine($"检查库存 {sku} x{qty}");
        return true;
    }
}

public class PaymentService
{
    public bool Charge(string userId, decimal amount)
    {
        Console.WriteLine($"扣款 {amount} 元，用户 {userId}");
        return true;
    }
}

public class ShippingService
{
    public void Arrange(string sku, int qty)
    {
        Console.WriteLine($"安排发货 {sku} x{qty}");
    }
}

// 外观：把「先校验、再扣款、最后发货，且任一步失败要回滚」的编排收在这里
public class OrderFacade
{
    private readonly InventoryService _inventory = new();
    private readonly PaymentService _payment = new();
    private readonly ShippingService _shipping = new();

    public bool PlaceOrder(string userId, string sku, int qty, decimal amount)
    {
        if (!_inventory.Check(sku, qty))
            return false;

        if (!_payment.Charge(userId, amount))
            return false;

        _shipping.Arrange(sku, qty);
        return true;
    }
}

// 调用方：一行搞定，不需要知道三个子系统及其顺序
var ok = new OrderFacade().PlaceOrder("u1001", "SKU-9", 2, 199.00m);

// 内在状态：树种，形状/贴图/颜色，可被成千上万棵树共享
public sealed class TreeType
{
    public TreeType(string name, string color, string texture)
    {
        Name = name; Color = color; Texture = texture;
    }

    public string Name { get; }
    public string Color { get; }
    public string Texture { get; }

    public void Draw(int x, int y, int ageYears)
        => Console.WriteLine($"在 ({x},{y}) 画 {Color} 的 {Name}，树龄 {ageYears} 年");
}

// 享元工厂：保证同 key 只创建一次
public static class TreeTypeFactory
{
    private static readonly Dictionary<string, TreeType> Cache = new();

    public static TreeType Get(string name, string color, string texture)
    {
        var key = $"{name}|{color}|{texture}";
        if (!Cache.TryGetValue(key, out var type))
        {
            type = new TreeType(name, color, texture);
            Cache[key] = type;
            Console.WriteLine($"[工厂] 创建新的 TreeType：{key}");
        }
        return type;
    }

    public static int Count => Cache.Count;
}

// 外在状态：位置和树龄，每棵树各不相同，不参与共享
public sealed class Tree
{
    private readonly TreeType _type;      // 共享
    private readonly int _x, _y, _age;    // 独有

    public Tree(TreeType type, int x, int y, int age)
        => (_type, _x, _y, _age) = (type, x, y, age);

    public void Draw() => _type.Draw(_x, _y, _age);
}

// 使用：一百万棵树，TreeType 只有 3 个实例
var rand = new Random(42);
for (var i = 0; i < 1_000_000; i++)
{
    var type = TreeTypeFactory.Get(
        rand.Next(2) == 0 ? "橡树" : "松树",
        "绿色",
        "tree.png");
    _ = new Tree(type, i % 1000, i / 1000, rand.Next(1, 50));
}
Console.WriteLine($"TreeType 实例数：{TreeTypeFactory.Count}");   // 2

public interface IReportService
{
    string Generate(string reportId);
}

// 真实对象：构造开销大，或者访问代价高
public class HeavyReportService : IReportService
{
    public HeavyReportService()
    {
        Console.WriteLine("[真实对象] 初始化中，加载数据集…");
        Thread.Sleep(500);          // 模拟昂贵初始化
    }

    public string Generate(string reportId) => $"报表 {reportId} 的内容";
}

// 虚拟代理 + 保护代理：延迟创建 + 权限校验 + 结果缓存
public class ReportServiceProxy : IReportService
{
    private readonly string _currentUserRole;
    private HeavyReportService? _real;                       // 延迟初始化
    private readonly Dictionary<string, string> _cache = new();

    public ReportServiceProxy(string currentUserRole) => _currentUserRole = currentUserRole;

    public string Generate(string reportId)
    {
        if (_currentUserRole != "Admin")
            throw new UnauthorizedAccessException($"角色 {_currentUserRole} 无权生成报表");

        if (_cache.TryGetValue(reportId, out var cached))
        {
            Console.WriteLine("[代理] 命中缓存，未创建真实对象");
            return cached;
        }

        _real ??= new HeavyReportService();     // 真正需要时才创建，且只创建一次
        var result = _real.Generate(reportId);
        _cache[reportId] = result;
        return result;
    }
}

// 使用
IReportService service = new ReportServiceProxy("Admin");
Console.WriteLine(service.Generate("R-001"));    // 触发真实对象创建
Console.WriteLine(service.Generate("R-001"));    // 走缓存

public record PurchaseRequest(string Item, decimal Amount, string Applicant);

public abstract class Approver
{
    private Approver? _next;

    // 返回抽象类型，支持链式串联
    public Approver SetNext(Approver next)
    {
        _next = next;
        return next;                  // 返回 next 而非 this，才写得出 a.SetNext(b).SetNext(c)
    }

    public virtual void Handle(PurchaseRequest request)
    {
        if (Approve(request))
        {
            Console.WriteLine($"{GetType().Name} 批准了 {request.Item}");
            return;
        }

        if (_next is null)
        {
            Console.WriteLine($"无人能批准 {request.Amount} 元的 {request.Item}");
            return;
        }

        _next.Handle(request);        // 交给下一环
    }

    protected abstract bool Approve(PurchaseRequest request);   // 返回是否已处理完
}

public class TeamLead : Approver
{
    protected override bool Approve(PurchaseRequest request)
    {
        if (request.Amount > 1000) return false;
        Console.WriteLine($"组长审批：{request.Item}");
        return true;
    }
}

public class Manager : Approver
{
    protected override bool Approve(PurchaseRequest request)
    {
        if (request.Amount > 10000) return false;
        Console.WriteLine($"经理审批：{request.Item}");
        return true;
    }
}

public class Director : Approver
{
    protected override bool Approve(PurchaseRequest request)
    {
        Console.WriteLine($"总监审批：{request.Item}");
        return true;                  // 兜底，一律批准
    }
}

// 组装链条：顺序即权限，可运行时增删
var chain = new TeamLead();
chain.SetNext(new Manager()).SetNext(new Director());

chain.Handle(new PurchaseRequest("显示器", 800, "张三"));       // 组长
chain.Handle(new PurchaseRequest("服务器", 50000, "李四"));     // 一路到总监

// 命令接口：支持执行与撤销
public interface ICommand
{
    void Execute();
    void Undo();
}

// 接收者：真正干活的对象
public class Light
{
    public string Room { get; init; } = string.Empty;
    public bool IsOn { get; private set; }

    public void TurnOn() { IsOn = true; Console.WriteLine($"{Room} 的灯亮了"); }
    public void TurnOff() { IsOn = false; Console.WriteLine($"{Room} 的灯灭了"); }
}

// 具体命令：把「对谁做什么」封成一个对象
public class TurnOnCommand : ICommand
{
    private readonly Light _light;
    public TurnOnCommand(Light light) => _light = light;

    public void Execute() => _light.TurnOn();
    public void Undo() => _light.TurnOff();     // 撤销即反向操作
}

public class TurnOffCommand : ICommand
{
    private readonly Light _light;
    public TurnOffCommand(Light light) => _light = light;

    public void Execute() => _light.TurnOff();
    public void Undo() => _light.TurnOn();
}

// 调用者：不认识 Light，只认识 ICommand，并维护历史用于撤销
public class RemoteControl
{
    private readonly Stack<ICommand> _history = new();

    public void Press(ICommand command)
    {
        command.Execute();
        _history.Push(command);
    }

    public void PressUndo()
    {
        if (_history.Count == 0)
        {
            Console.WriteLine("没有可撤销的操作");
            return;
        }
        _history.Pop().Undo();
    }
}

// 使用
var light = new Light { Room = "客厅" };
var remote = new RemoteControl();
remote.Press(new TurnOnCommand(light));
remote.Press(new TurnOffCommand(light));
remote.PressUndo();          // 又把灯打开
remote.PressUndo();          // 又关掉

// 抽象表达式
public interface IExpression
{
    int Interpret(Dictionary<string, int> context);
}

// 终结符表达式
public class NumberExpression : IExpression
{
    private readonly int _value;
    public NumberExpression(int value) => _value = value;

    public int Interpret(Dictionary<string, int> context) => _value;
}

public class VariableExpression : IExpression
{
    private readonly string _name;
    public VariableExpression(string name) => _name = name;

    public int Interpret(Dictionary<string, int> context)
    {
        if (!context.TryGetValue(_name, out var value))
            throw new InvalidOperationException($"未定义变量：{_name}");
        return value;
    }
}

// 非终结符表达式：组合子表达式
public class AddExpression : IExpression
{
    private readonly IExpression _left, _right;
    public AddExpression(IExpression left, IExpression right) => (_left, _right) = (left, right);

    public int Interpret(Dictionary<string, int> context)
        => _left.Interpret(context) + _right.Interpret(context);
}

public class MultiplyExpression : IExpression
{
    private readonly IExpression _left, _right;
    public MultiplyExpression(IExpression left, IExpression right) => (_left, _right) = (left, right);

    public int Interpret(Dictionary<string, int> context)
        => _left.Interpret(context) * _right.Interpret(context);
}

// 使用：手工构造表达式树，解释 x * 2 + 10
var context = new Dictionary<string, int> { ["x"] = 5 };
IExpression expr = new AddExpression(
    new MultiplyExpression(new VariableExpression("x"), new NumberExpression(2)),
    new NumberExpression(10));

Console.WriteLine(expr.Interpret(context));      // 20

public class Playlist : IEnumerable<string>
{
    private readonly List<string> _songs = new();

    public void Add(string song) => _songs.Add(song);

    // 编译器会把这个方法体变成状态机，yield return 是迭代器模式的语法糖
    public IEnumerator<string> GetEnumerator()
    {
        foreach (var song in _songs)
        {
            if (string.IsNullOrWhiteSpace(song))
                continue;                  // 过滤逻辑写在迭代器里
            yield return song;
        }
    }

    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

// 使用
var playlist = new Playlist();
playlist.Add("Song A");
playlist.Add("");
playlist.Add("Song B");

foreach (var song in playlist)          // foreach 编译后就是 GetEnumerator/MoveNext/Current
    Console.WriteLine(song);            // 只输出 A 和 B

// 中介者接口
public interface IChatRoom
{
    void Register(User user);
    void Send(string message, User sender);
}

public class ChatRoom : IChatRoom
{
    private readonly List<User> _users = new();

    public void Register(User user)
    {
        _users.Add(user);
        Console.WriteLine($"[系统] {user.Name} 加入聊天室");
    }

    public void Send(string message, User sender)
    {
        // 广播给除发送者外的所有人：多对多关系收敛到这一处
        foreach (var user in _users.Where(u => u != sender))
            user.Receive(message, sender.Name);
    }
}

public abstract class User
{
    protected readonly IChatRoom Room;      // 只认识中介者，不认识其他 User

    protected User(string name, IChatRoom room)
    {
        Name = name;
        Room = room;
        room.Register(this);
    }

    public string Name { get; }

    public void Send(string message)
    {
        Console.WriteLine($"{Name} 说：{message}");
        Room.Send(message, this);
    }

    public void Receive(string message, string from)
        => Console.WriteLine($"  {Name} 收到来自 {from} 的消息：{message}");
}

// 使用
var room = new ChatRoom();
var alice = new ChatRoomUser("Alice", room);
var bob = new ChatRoomUser("Bob", room);
alice.Send("大家好");      // Bob 收到，Alice 不重复收到

public class ChatRoomUser : User
{
    public ChatRoomUser(string name, IChatRoom room) : base(name, room) { }
}

// 备忘录：只读快照，对外只能读取不能修改
public sealed class EditorMemento
{
    internal EditorMemento(string content, int cursor)
        => (Content, Cursor) = (content, cursor);

    public string Content { get; }
    public int Cursor { get; }
    public DateTime SavedAt { get; } = DateTime.Now;
}

// 发起人：自己决定存什么、怎么恢复
public class TextEditor
{
    public string Content { get; private set; } = string.Empty;
    private int _cursor;

    public void Type(string text)
    {
        Content += text;
        _cursor = Content.Length;
    }

    public void MoveCursor(int position)
    {
        _cursor = Math.Clamp(position, 0, Content.Length);
        Console.WriteLine($"光标移动到 {_cursor}");
    }

    public EditorMemento Save() => new(Content, _cursor);   // 快照

    public void Restore(EditorMemento memento)
    {
        Content = memento.Content;
        _cursor = memento.Cursor;
        Console.WriteLine($"已恢复到 {memento.SavedAt:HH:mm:ss} 的状态");
    }
}

// 管理者：只管存取，不关心里面装的是什么
public class History
{
    private readonly Stack<EditorMemento> _snapshots = new();

    public void Push(EditorMemento memento) => _snapshots.Push(memento);

    public EditorMemento? Pop() => _snapshots.Count > 0 ? _snapshots.Pop() : null;
}

// 使用
var editor = new TextEditor();
var history = new History();

editor.Type("第一版内容");
history.Push(editor.Save());

editor.Type("，第二版补充");
editor.MoveCursor(0);

var snapshot = history.Pop();
if (snapshot is not null)
    editor.Restore(snapshot);

Console.WriteLine(editor.Content);      // 第一版内容

// 手写版本：理解结构
public interface IStockObserver
{
    void Update(string symbol, decimal price);
}

public class StockMarket
{
    private readonly List<IStockObserver> _observers = new();
    private readonly Dictionary<string, decimal> _prices = new();

    public void Subscribe(IStockObserver observer) => _observers.Add(observer);
    public void Unsubscribe(IStockObserver observer) => _observers.Remove(observer);

    public void SetPrice(string symbol, decimal price)
    {
        _prices[symbol] = price;
        Notify(symbol, price);
    }

    private void Notify(string symbol, decimal price)
    {
        // 注意：遍历的是副本，防止观察者在回调里退订导致集合被修改
        foreach (var observer in _observers.ToList())
            observer.Update(symbol, price);
    }
}

public class EmailAlert : IStockObserver
{
    public void Update(string symbol, decimal price)
        => Console.WriteLine($"[邮件] {symbol} 现价 {price}");
}

public class RiskMonitor : IStockObserver
{
    public void Update(string symbol, decimal price)
    {
        if (price > 100)
            Console.WriteLine($"[风控] {symbol} 价格过高：{price}");
    }
}

public class StockMarketWithEvent
{
    // 委托类型即观察者接口，event 保证外部只能 += / -=，不能直接赋值或触发
    public event EventHandler<StockPriceChangedEventArgs>? PriceChanged;

    public void SetPrice(string symbol, decimal price)
        => PriceChanged?.Invoke(this, new StockPriceChangedEventArgs(symbol, price));
}

public class StockPriceChangedEventArgs : EventArgs
{
    public StockPriceChangedEventArgs(string symbol, decimal price)
        => (Symbol, Price) = (symbol, price);

    public string Symbol { get; }
    public decimal Price { get; }
}

// 订阅：lambda 亦可
var market = new StockMarketWithEvent();
market.PriceChanged += (sender, e) => Console.WriteLine($"[邮件] {e.Symbol} 现价 {e.Price}");
market.SetPrice("AAPL", 120m);

public interface IOrderState
{
    void Pay(Order order);
    void Ship(Order order);
    void Complete(Order order);
    string Name { get; }
}

// 上下文：把行为委托给当前状态
public class Order
{
    public Order(string orderNo)
    {
        OrderNo = orderNo;
        State = new PendingPaymentState();
    }

    public string OrderNo { get; }
    public IOrderState State { get; set; }

    public void Pay() => State.Pay(this);
    public void Ship() => State.Ship(this);
    public void Complete() => State.Complete(this);

    public override string ToString() => $"订单 {OrderNo}（{State.Name}）";
}

public class PendingPaymentState : IOrderState
{
    public string Name => "待付款";

    public void Pay(Order order)
    {
        Console.WriteLine($"{order.OrderNo} 支付成功");
        order.State = new PaidState();          // 状态迁移在这里发生
    }

    public void Ship(Order order) => Console.WriteLine("未付款，无法发货");
    public void Complete(Order order) => Console.WriteLine("未付款，无法完成");
}

public class PaidState : IOrderState
{
    public string Name => "已付款";

    public void Pay(Order order) => Console.WriteLine("已付款，请勿重复支付");

    public void Ship(Order order)
    {
        Console.WriteLine($"{order.OrderNo} 已发货");
        order.State = new ShippedState();
    }

    public void Complete(Order order) => Console.WriteLine("未发货，无法完成");
}

public class ShippedState : IOrderState
{
    public string Name => "已发货";

    public void Pay(Order order) => Console.WriteLine("订单已发货，无需支付");
    public void Ship(Order order) => Console.WriteLine("请勿重复发货");

    public void Complete(Order order)
    {
        Console.WriteLine($"{order.OrderNo} 交易完成");
        order.State = new CompletedState();
    }
}

public class CompletedState : IOrderState
{
    public string Name => "已完成";

    public void Pay(Order order) => Console.WriteLine("订单已完成");
    public void Ship(Order order) => Console.WriteLine("订单已完成");
    public void Complete(Order order) => Console.WriteLine("订单已完成");
}

// 使用
var order = new Order("SO-20260928-001");
order.Ship();       // 未付款，无法发货
order.Pay();        // 支付成功 → 状态转为已付款
order.Ship();       // 已发货
order.Complete();   // 交易完成
Console.WriteLine(order);

// 策略接口
public interface IShippingStrategy
{
    decimal Calculate(decimal weightKg, string destination);
    string Name { get; }
}

public class StandardShipping : IShippingStrategy
{
    public string Name => "标准快递";
    public decimal Calculate(decimal weightKg, string destination)
        => 10m + weightKg * 2m;
}

public class ExpressShipping : IShippingStrategy
{
    public string Name => "顺丰特快";
    public decimal Calculate(decimal weightKg, string destination)
        => 25m + weightKg * 5m;
}

public class FreeShipping : IShippingStrategy
{
    public string Name => "包邮";
    public decimal Calculate(decimal weightKg, string destination) => 0m;
}

// 上下文：持有策略并在运行期可替换
public class ShippingCalculator
{
    private IShippingStrategy _strategy;

    public ShippingCalculator(IShippingStrategy strategy) => _strategy = strategy;

    public void SetStrategy(IShippingStrategy strategy) => _strategy = strategy;

    public decimal GetCost(decimal weightKg, string destination)
    {
        var cost = _strategy.Calculate(weightKg, destination);
        Console.WriteLine($"{_strategy.Name}：{cost} 元");
        return cost;
    }
}

// 使用
var calculator = new ShippingCalculator(new StandardShipping());
calculator.GetCost(3, "北京");              // 16

calculator.SetStrategy(new ExpressShipping());
calculator.GetCost(3, "北京");              // 40

public class ShippingCalculatorFunc
{
    private Func<decimal, string, decimal> _rule = (weight, dest) => 10m + weight * 2m;

    public void SetRule(Func<decimal, string, decimal> rule) => _rule = rule;

    public decimal GetCost(decimal weightKg, string destination) => _rule(weightKg, destination);
}

// 调用
var calc = new ShippingCalculatorFunc();
calc.SetRule((w, d) => w > 10 ? 0m : 15m);        // 包邮规则随时换

builder.Services.AddKeyedScoped<IShippingStrategy, StandardShipping>("standard");
builder.Services.AddKeyedScoped<IShippingStrategy, ExpressShipping>("express");

// 注入 IServiceProvider 后按名称取
var strategy = provider.GetRequiredKeyedService<IShippingStrategy>(userChoice);

public abstract class DataImporter
{
    // 模板方法：骨架固定，用 sealed 防止子类破坏流程
    public void Import(string filePath)
    {
        Open(filePath);
        var rows = Parse();
        Validate(rows);            // 可选钩子
        Save(rows);
        Close();                   // 无论成功失败都要清理
    }

    protected abstract void Open(string filePath);
    protected abstract List<string[]> Parse();
    protected abstract void Save(List<string[]> rows);

    // 钩子（Hook）：有默认实现，子类按需覆盖
    protected virtual void Validate(List<string[]> rows)
    {
        if (rows.Count == 0)
            throw new InvalidOperationException("文件内容为空");
    }

    protected virtual void Close() => Console.WriteLine("释放资源");
}

public class CsvImporter : DataImporter
{
    private StreamReader? _reader;

    protected override void Open(string filePath)
    {
        Console.WriteLine($"打开 CSV：{filePath}");
        _reader = new StreamReader(filePath);
    }

    protected override List<string[]> Parse()
    {
        Console.WriteLine("按逗号切分");
        return new List<string[]> { new[] { "1", "张三" }, new[] { "2", "李四" } };
    }

    protected override void Validate(List<string[]> rows)
    {
        base.Validate(rows);                       // 复用父类默认校验
        foreach (var row in rows)
            if (row.Length != 2)
                throw new InvalidOperationException("CSV 列数不正确");
    }

    protected override void Save(List<string[]> rows)
        => Console.WriteLine($"写入数据库，共 {rows.Count} 行");

    protected override void Close()
    {
        _reader?.Dispose();
        base.Close();
    }
}

// 使用：调用方只认 Import，不知道内部有多少步骤
new CsvImporter().Import("users.csv");

// 元素接口
public interface IShape
{
    void Accept(IShapeVisitor visitor);      // 第一次分派：确定元素类型
}

public class Circle : IShape
{
    public double Radius { get; init; }
    public void Accept(IShapeVisitor visitor) => visitor.Visit(this);
}

public class Rectangle : IShape
{
    public double Width { get; init; }
    public double Height { get; init; }
    public void Accept(IShapeVisitor visitor) => visitor.Visit(this);
}

// 访问者接口：每个元素类型一个 Visit 重载
public interface IShapeVisitor
{
    void Visit(Circle circle);           // 第二次分派：确定访问者类型
    void Visit(Rectangle rectangle);
}

// 新增操作 = 新增访问者，元素类一行不用改
public class AreaCalculator : IShapeVisitor
{
    public double TotalArea { get; private set; }

    public void Visit(Circle circle)
        => TotalArea += Math.PI * circle.Radius * circle.Radius;

    public void Visit(Rectangle rectangle)
        => TotalArea += rectangle.Width * rectangle.Height;
}

public class SvgExporter : IShapeVisitor
{
    public void Visit(Circle circle)
        => Console.WriteLine($"<circle r=\"{circle.Radius}\" />");

    public void Visit(Rectangle rectangle)
        => Console.WriteLine($"<rect width=\"{rectangle.Width}\" height=\"{rectangle.Height}\" />");
}

// 使用
var shapes = new List<IShape>
{
    new Circle { Radius = 2 },
    new Rectangle { Width = 3, Height = 4 }
};

var calculator = new AreaCalculator();
foreach (var shape in shapes)
    shape.Accept(calculator);            // 元素决定调哪个 Visit，访问者决定做什么

Console.WriteLine($"总面积：{calculator.TotalArea:F2}");   // 24.57

public static double GetArea(IShape shape) => shape switch
{
    Circle c => Math.PI * c.Radius * c.Radius,
    Rectangle r => r.Width * r.Height,
    _ => throw new NotSupportedException($"未知形状：{shape.GetType().Name}")
};