亚辉的博客

public class FileManager
{
    public void SaveFile(string content)
    {
        // 保存文件的具体实现
    }

    public void ParseFile(string filePath)
    {
        // 解析文件的具体实现
    }
}

public interface IShape
{
    void Draw();
}

public class Circle : IShape
{
    public void Draw()
    {
        // 画圆的具体实现
    }
}

public class Square : IShape
{
    public void Draw()
    {
        // 画正方形的具体实现
    }
}

public class Rectangle
{
    protected int Width;
    protected int Height;

    public void SetWidth(int width)
    {
        Width = width;
    }

    public void SetHeight(int height)
    {
        Height = height;
    }
}

public class Square : Rectangle
{
    public override void SetWidth(int width)
    {
        Width = width;
        Height = width;
    }

    public override void SetHeight(int height)
    {
        Width = height;
        Height = height;
    }
}

public interface IWriter
{
    void Write(string message);
}

public class ConsoleWriter : IWriter
{
    public void Write(string message)
    {
        Console.WriteLine("Writing to console: " + message);
    }
}

public class MessageProcessor
{
    private readonly IWriter _writer;

    public MessageProcessor(IWriter writer)
    {
        _writer = writer;
    }

    public void ProcessMessage(string message)
    {
        // 处理消息的逻辑
        _writer.Write(message);
    }
}

public interface IWorker
{
    void Work();
    void Eat();
}

public class Programmer : IWorker
{
    public void Work()
    {
        // 程序员的工作
    }

    public void Eat()
    {
        // 程序员的吃饭
    }
}

public class Janitor : IWorker
{
    public void Work()
    {
        // 看门员的工作
    }

    public void Eat()
    {
        // 看门员的吃饭
    }
}

public class Engine
{
    public void Start()
    {
        // 引擎启动逻辑
    }
}

public class Car
{
    private readonly Engine _engine;

    public Car(Engine engine)
    {
        _engine = engine;
    }

    public void Start()
    {
        _engine.Start();
        // 其他汽车启动逻辑
    }
}

using System;

// 抽象状态类
public abstract class State
{
    public abstract void Handle(Context context);
}

// 具体状态类 A
public class ConcreteStateA : State
{
    public override void Handle(Context context)
    {
        Console.WriteLine("Handling with ConcreteStateA");
        // 在具体状态类中可以改变上下文的状态
        context.SetState(new ConcreteStateB());
    }
}

// 具体状态类 B
public class ConcreteStateB : State
{
    public override void Handle(Context context)
    {
        Console.WriteLine("Handling with ConcreteStateB");
        // 在具体状态类中可以改变上下文的状态
        context.SetState(new ConcreteStateA());
    }
}

// 上下文类
public class Context
{
    private State state;

    public Context(State initialState)
    {
        this.state = initialState;
    }

    public void Request()
    {
        // 上下文类将请求委托给当前状态处理
        state.Handle(this);
    }

    public void SetState(State newState)
    {
        this.state = newState;
    }
}

class Program
{
    static void Main()
    {
        // 创建上下文对象，初始状态为 ConcreteStateA
        Context context = new Context(new ConcreteStateA());

        // 发起请求，由 ConcreteStateA 处理
        context.Request();

        // 发起请求，由 ConcreteStateB 处理
        context.Request();
    }
}

using System;
using System.Collections.Generic;

// 抽象中介者
public interface Mediator
{
    void RegisterColleague(Colleague colleague);
    void SendMessage(Colleague colleague, string message);
}

// 抽象同事类
public abstract class Colleague
{
    protected Mediator mediator;

    public Colleague(Mediator mediator)
    {
        this.mediator = mediator;
    }

    public abstract void Send(string message);
    public abstract void Receive(string message);
}

// 具体中介者
public class ConcreteMediator : Mediator
{
    private List<Colleague> colleagues;

    public ConcreteMediator()
    {
        this.colleagues = new List<Colleague>();
    }

    public void RegisterColleague(Colleague colleague)
    {
        colleagues.Add(colleague);
    }

    public void SendMessage(Colleague colleague, string message)
    {
        foreach (var c in colleagues)
        {
            if (c != colleague)
            {
                c.Receive(message);
            }
        }
    }
}

// 具体同事类A
public class ConcreteColleagueA : Colleague
{
    public ConcreteColleagueA(Mediator mediator) : base(mediator) { }

    public override void Send(string message)
    {
        Console.WriteLine("Colleague A sends message: " + message);
        mediator.SendMessage(this, message);
    }

    public override void Receive(string message)
    {
        Console.WriteLine("Colleague A receives message: " + message);
    }
}

// 具体同事类B
public class ConcreteColleagueB : Colleague
{
    public ConcreteColleagueB(Mediator mediator) : base(mediator) { }

    public override void Send(string message)
    {
        Console.WriteLine("Colleague B sends message: " + message);
        mediator.SendMessage(this, message);
    }

    public override void Receive(string message)
    {
        Console.WriteLine("Colleague B receives message: " + message);
    }
}

class Program
{
    static void Main()
    {
        // 创建具体中介者对象
        ConcreteMediator mediator = new ConcreteMediator();

        // 创建具体同事类对象，并注册到中介者
        ConcreteColleagueA colleagueA = new ConcreteColleagueA(mediator);
        ConcreteColleagueB colleagueB = new ConcreteColleagueB(mediator);
        mediator.RegisterColleague(colleagueA);
        mediator.RegisterColleague(colleagueB);

        // 同事类之间通过中介者进行通信
        colleagueA.Send("Hello from Colleague A");
        colleagueB.Send("Hi from Colleague B");
    }
}

using System;

// 抽象处理者类
public abstract class Handler
{
    protected Handler successor;

    public void SetSuccessor(Handler successor)
    {
        this.successor = successor;
    }

    public abstract void HandleRequest(int request);
}

// 具体处理者A
public class ConcreteHandlerA : Handler
{
    public override void HandleRequest(int request)
    {
        if (request >= 0 && request < 10)
        {
            Console.WriteLine($"Concrete Handler A handles request {request}");
        }
        else if (successor != null)
        {
            successor.HandleRequest(request);
        }
    }
}

// 具体处理者B
public class ConcreteHandlerB : Handler
{
    public override void HandleRequest(int request)
    {
        if (request >= 10 && request < 20)
        {
            Console.WriteLine($"Concrete Handler B handles request {request}");
        }
        else if (successor != null)
        {
            successor.HandleRequest(request);
        }
    }
}

class Program
{
    static void Main()
    {
        // 创建具体处理者对象
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();

        // 设置处理链
        handlerA.SetSuccessor(handlerB);

        // 发送请求，实际上会从处理链的头部开始，依次尝试每个处理者
        handlerA.HandleRequest(15);
    }
}

using System;

// 抽象类
public abstract class AbstractClass
{
    // 模板方法定义了算法的骨架，将某些步骤的实现交给子类
    public void TemplateMethod()
    {
        PrimitiveOperation1();
        PrimitiveOperation2();
    }

    // 原语操作1，延迟到子类实现
    protected abstract void PrimitiveOperation1();

    // 原语操作2，延迟到子类实现
    protected abstract void PrimitiveOperation2();
}

// 具体类
public class ConcreteClass : AbstractClass
{
    // 实现原语操作1
    protected override void PrimitiveOperation1()
    {
        Console.WriteLine("ConcreteClass Primitive Operation 1");
    }

    // 实现原语操作2
    protected override void PrimitiveOperation2()
    {
        Console.WriteLine("ConcreteClass Primitive Operation 2");
    }
}

class Program
{
    static void Main()
    {
        // 创建具体类对象
        ConcreteClass concreteClass = new ConcreteClass();

        // 调用模板方法，实际上会执行具体类中定义的算法骨架
        concreteClass.TemplateMethod();
    }
}

using System;

// 命令接口
public interface Command
{
    void Execute();
    void Undo();
}

// 具体命令类
public class ConcreteCommand : Command
{
    private Receiver receiver;

    public ConcreteCommand(Receiver receiver)
    {
        this.receiver = receiver;
    }

    public void Execute()
    {
        receiver.Action();
    }

    public void Undo()
    {
        // 提供撤销操作的具体实现
    }
}

// 接收者类
public class Receiver
{
    public void Action()
    {
        Console.WriteLine("Receiver Action");
    }
}

// 请求发送者类
public class Invoker
{
    private Command command;

    public void SetCommand(Command command)
    {
        this.command = command;
    }

    public void ExecuteCommand()
    {
        command.Execute();
    }

    public void UndoCommand()
    {
        command.Undo();
    }
}

class Program
{
    static void Main()
    {
        // 创建接收者对象
        Receiver receiver = new Receiver();

        // 创建具体命令对象，传入接收者对象
        Command command = new ConcreteCommand(receiver);

        // 创建请求发送者对象，传入具体命令对象
        Invoker invoker = new Invoker();
        invoker.SetCommand(command);

        // 发送请求，实际上会执行接收者对象的操作
        invoker.ExecuteCommand();
    }
}

using System;
using System.Collections.Generic;

// 主题接口
public interface Subject
{
    void Attach(Observer observer);
    void Detach(Observer observer);
    void Notify();
}

// 具体主题类
public class ConcreteSubject : Subject
{
    private string state;
    private List<Observer> observers;

    public ConcreteSubject()
    {
        this.observers = new List<Observer>();
    }

    public string GetState()
    {
        return state;
    }

    public void SetState(string state)
    {
        this.state = state;
        Notify();
    }

    public void Attach(Observer observer)
    {
        observers.Add(observer);
    }

    public void Detach(Observer observer)
    {
        observers.Remove(observer);
    }

    public void Notify()
    {
        foreach (var observer in observers)
        {
            observer.Update();
        }
    }
}

// 观察者接口
public interface Observer
{
    void Update();
}

// 具体观察者类
public class ConcreteObserver : Observer
{
    private string name;
    private ConcreteSubject subject;

    public ConcreteObserver(string name, ConcreteSubject subject)
    {
        this.name = name;
        this.subject = subject;
    }

    public void Update()
    {
        Console.WriteLine($"Observer {name} received the updated state: {subject.GetState()}");
    }
}

class Program
{
    static void Main()
    {
        // 创建具体主题对象
        ConcreteSubject subject = new ConcreteSubject();

        // 创建具体观察者对象，并注册到主题
        ConcreteObserver observerA = new ConcreteObserver("Observer A", subject);
        ConcreteObserver observerB = new ConcreteObserver("Observer B", subject);
        subject.Attach(observerA);
        subject.Attach(observerB);

        // 设置主题状态，观察者收到通知并更新
        subject.SetState("New State");
    }
}

using System;

// 上下文类，保存解释器需要的信息
public class Context
{
    private readonly string input;
    private int currentTokenIndex;

    public Context(string input)
    {
        this.input = input;
        this.currentTokenIndex = 0;
    }

    // 获取下一个标记
    public string GetNextToken()
    {
        // 简化示例，实际中可能需要更复杂的逻辑
        if (currentTokenIndex < input.Length)
        {
            return input[currentTokenIndex++].ToString();
        }
        return null;
    }

    // 获取当前标记
    public string GetToken()
    {
        // 简化示例，实际中可能需要更复杂的逻辑
        if (currentTokenIndex < input.Length)
        {
            return input[currentTokenIndex].ToString();
        }
        return null;
    }
}

// 抽象表达式类
public abstract class AbstractExpression
{
    public abstract void Interpret(Context context);
}

// 终结符表达式类
public class TerminalExpression : AbstractExpression
{
    public override void Interpret(Context context)
    {
        string token = context.GetToken();
        if (token != null)
        {
            Console.WriteLine($"Terminal Expression interprets token: {token}");
        }
    }
}

// 非终结符表达式类
public class NonterminalExpression : AbstractExpression
{
    public override void Interpret(Context context)
    {
        string token = context.GetToken();
        if (token != null)
        {
            Console.WriteLine($"Nonterminal Expression interprets token: {token}");
        }
    }
}

class Program
{
    static void Main()
    {
        // 创建上下文对象，传入待解释的语言
        Context context = new Context("A B C D");

        // 创建终结符和非终结符表达式对象
        AbstractExpression terminalExpression = new TerminalExpression();
        AbstractExpression nonterminalExpression = new NonterminalExpression();

        // 解释语言中的每个标记
        while (context.GetToken() != null)
        {
            // 判断标记类型，选择不同的表达式进行解释
            if (context.GetToken() == "A" || context.GetToken() == "B")
            {
                terminalExpression.Interpret(context);
            }
            else
            {
                nonterminalExpression.Interpret(context);
            }
        }
    }
}