亚辉的博客

设计模式-行为型模式-观察者模式

发表于 2023-12-09 更新于 2025-04-18 分类于架构思想

观察者模式 - 行为型模式的消息发布与订阅

在软件设计中，观察者模式是一种行为型设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听并被通知某个主题对象的状态改变。观察者模式的核心思想是将主题和观察者分离，使得主题对象的状态改变可以通知到所有依赖于它的观察者对象。本文将深入讨论观察者模式的概念、实现方式以及在实际应用中的使用场景。

观察者模式的概念

观察者模式（Observer Pattern）是一种行为型设计模式，其核心思想是定义了一种一对多的依赖关系，让多个观察者对象同时监听并被通知某个主题对象的状态改变。观察者模式的主要角色包括主题（Subject）、具体主题（ConcreteSubject）、观察者（Observer）和具体观察者（ConcreteObserver）。

观察者模式的 UML 类图

classDiagram
    class Subject {
        + Attach(observer: Observer): void
        + Detach(observer: Observer): void
        + Notify(): void
    }

    class ConcreteSubject {
        - state: string
        - observers: List
        + GetState(): string
        + SetState(state: string): void
        + Attach(observer: Observer): void
        + Detach(observer: Observer): void
        + Notify(): void
    }

    class Observer {
        + Update(): void
    }

    class ConcreteObserver {
        - name: string
        - subject: ConcreteSubject
        + Update(): void
    }

    Subject <|.. ConcreteSubject
    Observer <|.. ConcreteObserver
    ConcreteObserver --> ConcreteSubject

观察者模式的实现方式

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");
    }
}

总结

观察者模式是一种行为型设计模式，通过定义了一种一对多的依赖关系，让多个观察者对象同时监听并被通知某个主题对象的状态改变。观察者模式适用于实现消息发布与订阅、解耦主题和观察者的场景。在实际应用中，观察者模式常用于实现事件处理机制、图形界面组件的刷新等场景。

设计模式-行为型模式-访问者模式

发表于 2023-12-09 更新于 2025-04-18 分类于架构思想

访问者模式 - 行为型模式的灵活扩展

在软件设计中，访问者模式是一种行为型设计模式，它表示一个操作用于处理对象结构中的各元素，可以在不改变这些元素的类的前提下定义这些操作。访问者模式的核心思想是将数据结构与数据操作分离，使得数据结构可以独立于数据操作的变化。本文将深入讨论访问者模式的概念、实现方式以及在实际应用中的使用场景。

访问者模式的概念

访问者模式（Visitor Pattern）是一种行为型设计模式，其核心思想是表示一个操作用于处理对象结构中的各元素，可以在不改变这些元素的类的前提下定义这些操作。访问者模式主要包括四个角色：访问者（Visitor）、具体访问者（ConcreteVisitor）、元素（Element）和具体元素（ConcreteElement）。

访问者模式的 UML 类图

classDiagram
    class Visitor {
        + VisitConcreteElementA(element: ConcreteElementA): void
        + VisitConcreteElementB(element: ConcreteElementB): void
    }

    class ConcreteVisitor {
        + VisitConcreteElementA(element: ConcreteElementA): void
        + VisitConcreteElementB(element: ConcreteElementB): void
    }

    class Element {
        + Accept(visitor: Visitor): void
    }

    class ConcreteElementA {
        + Accept(visitor: Visitor): void
    }

    class ConcreteElementB {
        + Accept(visitor: Visitor): void
    }

    Visitor <|.. ConcreteVisitor
    Element <|.. ConcreteElementA
    Element <|.. ConcreteElementB

访问者模式的实现方式

using System;

// 访问者接口
public interface Visitor
{
    void VisitConcreteElementA(ConcreteElementA element);
    void VisitConcreteElementB(ConcreteElementB element);
}

// 具体访问者类
public class ConcreteVisitor : Visitor
{
    public void VisitConcreteElementA(ConcreteElementA element)
    {
        Console.WriteLine("Visitor is visiting ConcreteElementA");
    }

    public void VisitConcreteElementB(ConcreteElementB element)
    {
        Console.WriteLine("Visitor is visiting ConcreteElementB");
    }
}

// 元素接口
public interface Element
{
    void Accept(Visitor visitor);
}

// 具体元素类 A
public class ConcreteElementA : Element
{
    public void Accept(Visitor visitor)
    {
        visitor.VisitConcreteElementA(this);
    }
}

// 具体元素类 B
public class ConcreteElementB : Element
{
    public void Accept(Visitor visitor)
    {
        visitor.VisitConcreteElementB(this);
    }
}

访问者模式的应用场景

访问者模式适用于以下情况：

一个对象结构包含多个类型的对象，且需要对这些对象进行不同的处理。
需要对对象结构中的元素进行频繁变化的操作。
对象结构中的元素类的个数比较稳定，但其行为操作算法经常变化。

访问者模式的优势

解耦性好： 访问者模式将数据结构与数据操作分离，使得数据结构可以独立于数据操作的变化。
可扩展性： 可以在不修改元素类的前提下增加新的访问者，实现对元素类的新的操作。
灵活性： 可以通过不同的具体访问者来实现不同的业务操作，达到灵活扩展的目的。

使用示例

class Program
{
    static void Main()
    {
        // 创建具体元素对象
        ConcreteElementA elementA = new ConcreteElementA();
        ConcreteElementB elementB = new ConcreteElementB();

        // 创建具体访问者对象
        ConcreteVisitor visitor = new ConcreteVisitor();

        // 元素接受访问者的访问
        elementA.Accept(visitor);
        elementB.Accept(visitor);
    }
}

总结

访问者模式是一种行为型设计模式，通过将数据结构与数据操作分离，使得数据结构可以独立于数据操作的变化。访问者模式适用于一个对象结构包含多个类型的对象，且需要对这些对象进行不同的处理的场景。在实际应用中，访问者模式常用于处理复杂的对象结构、业务规则的动态变化等场景。

设计模式-行为型模式-迭代器模式

发表于 2023-12-09 更新于 2025-04-18 分类于架构思想

迭代器模式 - 行为型模式的元素访问者

在软件设计中，迭代器模式是一种行为型设计模式，它提供一种顺序访问集合对象元素的方法，而不暴露集合的内部表示。迭代器模式使得可以在不知道集合内部结构的情况下，按顺序访问集合中的元素。本文将深入讨论迭代器模式的概念、实现方式以及在实际应用中的使用场景。

迭代器模式的概念

迭代器模式（Iterator Pattern）是一种行为型设计模式，其核心思想是提供一种顺序访问集合对象元素的方法，而不暴露集合的内部表示。迭代器模式将对集合元素的遍历与集合的具体实现分离，使得可以在不知道集合内部结构的情况下，按顺序访问集合中的元素。

迭代器模式的实现方式

using System;
using System.Collections.Generic;

// 抽象迭代器接口
public interface Iterator
{
    object Next();
    bool HasNext();
}

// 具体迭代器类
public class ConcreteIterator : Iterator
{
    private int index;
    private ConcreteAggregate aggregate;

    public ConcreteIterator(ConcreteAggregate aggregate)
    {
        this.index = 0;
        this.aggregate = aggregate;
    }

    public object Next()
    {
        if (HasNext())
        {
            return aggregate.GetItemAt(index++);
        }
        return null;
    }

    public bool HasNext()
    {
        return index < aggregate.Count();
    }
}

// 抽象集合接口
public interface Aggregate
{
    Iterator CreateIterator();
}

// 具体集合类
public class ConcreteAggregate : Aggregate
{
    private List<object> items;

    public ConcreteAggregate()
    {
        this.items = new List<object>();
    }

    public void AddItem(object item)
    {
        items.Add(item);
    }

    public int Count()
    {
        return items.Count;
    }

    public object GetItemAt(int index)
    {
        return items[index];
    }

    public Iterator CreateIterator()
    {
        return new ConcreteIterator(this);
    }
}

迭代器模式的应用场景

迭代器模式适用于以下情况：

需要提供一种统一的方法顺序访问一个聚合对象中的各个元素，而不暴露其内部表示。
需要对聚合对象的遍历操作进行抽象，使得可以在不依赖具体聚合类型的情况下遍历聚合对象。
需要支持多种不同遍历方式，如正序遍历、倒序遍历等。

迭代器模式的优势

简化客户端代码： 迭代器模式将对集合元素的遍历与集合的具体实现分离，简化了客户端代码。
支持多种遍历方式： 可以轻松地扩展或修改迭代器，支持多种不同的遍历方式。
隔离集合的具体实现： 客户端只需要通过迭代器接口访问集合元素，不需要关心集合的具体实现。

使用示例

class Program
{
    static void Main()
    {
        // 创建具体集合对象
        ConcreteAggregate aggregate = new ConcreteAggregate();
        aggregate.AddItem("Item 1");
        aggregate.AddItem("Item 2");
        aggregate.AddItem("Item 3");

        // 创建迭代器对象
        Iterator iterator = aggregate.CreateIterator();

        // 使用迭代器顺序访问集合元素
        while (iterator.HasNext())
        {
            Console.WriteLine(iterator.Next());
        }
    }
}

总结

迭代器模式是一种行为型设计模式，通过提供一种顺序访问集合对象元素的方法，将对集合元素的遍历与集合的具体实现分离。迭代器模式简化了客户端代码，支持多种遍历方式，隔离了集合的具体实现。在实际应用中，迭代器模式常用于处理集合元素的遍历和访问。

设计模式-行为型模式-策略模式

发表于 2023-12-09 更新于 2025-04-18 分类于架构思想

策略模式 - 行为型模式的智慧选择

在软件设计中，策略模式是一种行为型设计模式，它定义了一系列算法，将每个算法封装起来，并使它们可以相互替换。策略模式让算法的变化独立于使用算法的客户端，使得客户端可以根据需要选择不同的算法。本文将深入讨论策略模式的概念、实现方式以及在实际应用中的使用场景。

策略模式的概念

策略模式（Strategy Pattern）是一种行为型设计模式，其核心思想是定义了一系列算法，将每个算法封装起来，并使它们可以相互替换。策略模式使得算法的变化独立于使用算法的客户端，客户端可以根据需要在运行时选择不同的算法。策略模式主要包括三个角色：环境类（Context）、抽象策略类（Strategy）和具体策略类（ConcreteStrategy）。

策略模式的 UML 类图

classDiagram
    class Context {
        - strategy: Strategy
        + SetStrategy(strategy: Strategy): void
        + ExecuteStrategy(): void
    }

    class Strategy {
        + Execute(): void
    }

    class ConcreteStrategyA
    class ConcreteStrategyB

    Context --> Strategy
    Strategy <|.. ConcreteStrategyA
    Strategy <|.. ConcreteStrategyB

策略模式的实现方式

using System;

// 抽象策略类
public interface Strategy
{
    void Execute();
}

// 具体策略类 A
public class ConcreteStrategyA : Strategy
{
    public void Execute()
    {
        Console.WriteLine("Executing ConcreteStrategyA");
    }
}

// 具体策略类 B
public class ConcreteStrategyB : Strategy
{
    public void Execute()
    {
        Console.WriteLine("Executing ConcreteStrategyB");
    }
}

// 环境类
public class Context
{
    private Strategy strategy;

    public void SetStrategy(Strategy strategy)
    {
        this.strategy = strategy;
    }

    public void ExecuteStrategy()
    {
        strategy.Execute();
    }
}

策略模式的应用场景

策略模式适用于以下情况：

一个系统需要动态地在多个算法中选择一个。
一个对象有许多行为，而在不同的情况下只有其中一种行为能够生效。
系统需要在运行时根据环境状态切换算法。

策略模式的优势

增加新的策略： 策略模式允许新增加的策略类，使得系统更加灵活和易于扩展。
算法替换： 策略模式使得算法的变化独立于使用算法的客户端，客户端可以根据需要选择不同的算法。
避免条件语句： 策略模式可以避免大量的条件语句，使得代码更加清晰。

使用示例

class Program
{
    static void Main()
    {
        // 创建环境对象
        Context context = new Context();

        // 设置具体策略类 A，执行策略
        context.SetStrategy(new ConcreteStrategyA());
        context.ExecuteStrategy();

        // 设置具体策略类 B，执行策略
        context.SetStrategy(new ConcreteStrategyB());
        context.ExecuteStrategy();
    }
}

总结

策略模式是一种行为型设计模式，通过将算法封装成独立的策略类，使得算法的变化独立于使用算法的客户端。策略模式适用于一个系统需要在多个算法中选择一个，或者一个对象有多个行为，但在不同的情况下只有其中一种行为生效的场景。在实际应用中，策略模式常用于实现算法的动态切换、行为的灵活组合等场景。

设计模式-行为型模式-备忘录模式

发表于 2023-12-09 更新于 2025-04-18 分类于架构思想

备忘录模式 - 行为型模式的状态保存者

在软件设计中，备忘录模式是一种行为型设计模式，它允许在不暴露对象实现细节的情况下，捕获和恢复对象的内部状态。备忘录模式主要涉及三个角色：发起人（Originator）、备忘录（Memento）和管理者（Caretaker）。本文将深入讨论备忘录模式的概念、实现方式以及在实际应用中的使用场景。

备忘录模式的概念

备忘录模式（Memento Pattern）是一种行为型设计模式，其核心思想是允许在不暴露对象实现细节的情况下，捕获和恢复对象的内部状态。备忘录模式主要包括三个角色：发起人（Originator）、备忘录（Memento）和管理者（Caretaker）。发起人负责创建备忘录，备忘录用于保存发起人的内部状态，而管理者负责存储和恢复备忘录。

备忘录模式的 UML 类图

classDiagram
    class Memento {
        - state: string
        + GetState(): string
    }

    class Originator {
        - state: string
        + SetState(state: string): void
        + CreateMemento(): Memento
        + RestoreMemento(memento: Memento): void
    }

    class Caretaker {
        - memento: Memento
        + GetMemento(): Memento
        + SetMemento(memento: Memento): void
    }

    Originator ..> Memento
    Originator <-- Caretaker

备忘录模式的实现方式

using System;

// 备忘录类
public class Memento
{
    private string state;

    public Memento(string state)
    {
        this.state = state;
    }

    public string GetState()
    {
        return state;
    }
}

// 发起人类
public class Originator
{
    private string state;

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

    public Memento CreateMemento()
    {
        return new Memento(state);
    }

    public void RestoreMemento(Memento memento)
    {
        this.state = memento.GetState();
    }

    public void ShowState()
    {
        Console.WriteLine("Current State: " + state);
    }
}

// 管理者类
public class Caretaker
{
    private Memento memento;

    public Memento GetMemento()
    {
        return memento;
    }

    public void SetMemento(Memento memento)
    {
        this.memento = memento;
    }
}

备忘录模式的应用场景

备忘录模式适用于以下情况：

需要实现对象状态的保存和恢复功能，但不希望暴露对象的实现细节。
对象的状态变化需要被保存，以便在后续需要时进行恢复。
需要提供撤销操作的功能，即能够恢复到之前的状态。

备忘录模式的优势

封装性好： 备忘录模式将对象的状态保存和恢复封装在备忘录对象中，隐藏了对象的实现细节。
灵活性： 可以随时保存对象的状态，提供多个时间点的状态选择。
易于扩展： 新的备忘录类和发起人类可以很容易地添加到系统中，不影响其他类。

使用示例

class Program
{
    static void Main()
    {
        // 创建发起人和管理者对象
        Originator originator = new Originator();
        Caretaker caretaker = new Caretaker();

        // 设置发起人状态，并显示当前状态
        originator.SetState("State 1");
        originator.ShowState();

        // 创建备忘录并保存当前状态
        Memento memento = originator.CreateMemento();
        caretaker.SetMemento(memento);

        // 修改发起人状态，并显示当前状态
        originator.SetState("State 2");
        originator.ShowState

();

        // 恢复到之前的状态，并显示当前状态
        originator.RestoreMemento(caretaker.GetMemento());
        originator.ShowState();
    }
}

总结

备忘录模式是一种行为型设计模式，通过将对象的状态保存和恢复封装在备忘录对象中，实现了对对象状态的灵活管理。备忘录模式适用于需要实现对象状态的保存和恢复功能，同时不希望暴露对象实现细节的场景。在实际应用中，备忘录模式常用于实现撤销操作、版本控制等功能。

设计模式-结构型模式-组合模式

发表于 2023-12-09 更新于 2025-04-18 分类于架构思想

组合模式 - 结构型模式的层层叠加

在软件设计中，组合模式是一种结构型设计模式，它通过将对象组合成树状结构，以表示“部分-整体”的层次结构。本文将深入讨论组合模式的概念、实现方式以及在实际应用中的使用场景。

组合模式的概念

组合模式（Composite Pattern）是一种结构型设计模式，其核心思想是将对象组合成树状结构，以表示“部分-整体”的层次结构。组合模式使得客户端可以统一地对待单个对象和组合对象。

组合模式的 UML 类图

classDiagram
    class Component {
        + Operation(): void
    }

    class Leaf {
        + Operation(): void
    }

    class Composite {
        + Add(component: Component): void
        + Remove(component: Component): void
        + Operation(): void
    }

    Component <|-- Leaf
    Component <|-- Composite

组合模式的实现方式

using System;
using System.Collections.Generic;

// 抽象组件类
public abstract class Component
{
    public abstract void Operation();
}

// 叶子组件类
public class Leaf : Component
{
    public override void Operation()
    {
        Console.WriteLine("Leaf Operation");
    }
}

// 复合组件类
public class Composite : Component
{
    private List<Component> children = new List<Component>();

    public void Add(Component component)
    {
        children.Add(component);
    }

    public void Remove(Component component)
    {
        children.Remove(component);
    }

    public override void Operation()
    {
        Console.WriteLine("Composite Operation");

        foreach (var child in children)
        {
            child.Operation();
        }
    }
}

组合模式的应用场景

组合模式适用于以下情况：

系统需要处理整体与部分的关系，希望客户端可以忽略单个对象与组合对象的差异。
系统中的对象可以形成树状结构，且客户端希望一致地对待所有对象。
希望在不同层次结构中使用相同的操作，而不用关心对象的具体类型。

组合模式的优势

简化客户端代码： 客户端无需区分处理单个对象和组合对象，统一了接口，简化了客户端代码。
灵活性和可扩展性： 组合模式使得系统具备灵活性和可扩展性，可以方便地添加新的叶子节点或者复合节点。
统一操作： 组合模式使得客户端可以统一地对待单个对象和组合对象，无需关心对象的具体类型。

使用示例

class Program
{
    static void Main()
    {
        // 创建叶子对象
        Leaf leaf1 = new Leaf();
        Leaf leaf2 = new Leaf();

        // 创建复合对象，并将叶子对象添加进去
        Composite composite = new Composite();
        composite.Add(leaf1);
        composite.Add(leaf2);

        // 调用复合对象的操作方法，实际上会递归调用叶子对象的操作方法
        composite.Operation();
    }
}

总结

组合模式是一种强大的结构型设计模式，通过将对象组合成树状结构，使得客户端可以统一地对待单个对象和组合对象。组合模式在处理整体与部分的关系、以及构建具有层次结构的对象时，能够提供简洁而灵活的解决方案。在实际应用中，组合模式需要注意递归调用的性能问题，确保在大规模树状结构中的性能表现。

设计模式-结构型模式-装饰模式

发表于 2023-12-09 更新于 2025-04-18 分类于架构思想

装饰模式 - 结构型模式的灵活包装

在软件设计中，装饰模式是一种结构型设计模式，它允许在不改变对象接口的情况下，动态地将责任附加到对象上。本文将深入讨论装饰模式的概念、实现方式以及在实际应用中的使用场景。

装饰模式的概念

装饰模式（Decorator Pattern）是一种结构型设计模式，其核心思想是通过装饰器类包装原始类，以动态地扩展其功能，而无需修改原始类的接口。装饰模式是一种通过对象组合而非继承的方式，使得行为可以被灵活地扩展。

装饰模式的 UML 类图

classDiagram
    class Component {
        + Operation(): void
    }

    class ConcreteComponent {
        + Operation(): void
    }

    class Decorator {
        - component: Component
        + Operation(): void
    }

    class ConcreteDecoratorA {
        + Operation(): void
        + AddedBehavior(): void
    }

    class ConcreteDecoratorB {
        + Operation(): void
        + AddedBehavior(): void
    }

    Component <|.. ConcreteComponent
    Component <|.. Decorator
    Decorator <|-- ConcreteDecoratorA
    Decorator <|-- ConcreteDecoratorB

装饰模式的实现方式

using System;

// 抽象组件类
public abstract class Component
{
    public abstract void Operation();
}

// 具体组件类
public class ConcreteComponent : Component
{
    public override void Operation()
    {
        Console.WriteLine("Concrete Component Operation");
    }
}

// 抽象装饰器类
public abstract class Decorator : Component
{
    protected Component component;

    public void SetComponent(Component component)
    {
        this.component = component;
    }

    public override void Operation()
    {
        if (component != null)
        {
            component.Operation();
        }
    }
}

// 具体装饰器类A
public class ConcreteDecoratorA : Decorator
{
    public override void Operation()
    {
        base.Operation();
        AddedBehavior();
        Console.WriteLine("Concrete Decorator A Operation");
    }

    private void AddedBehavior()
    {
        Console.WriteLine("Added Behavior A");
    }
}

// 具体装饰器类B
public class ConcreteDecoratorB : Decorator
{
    public override void Operation()
    {
        base.Operation();
        AddedBehavior();
        Console.WriteLine("Concrete Decorator B Operation");
    }

    private void AddedBehavior()
    {
        Console.WriteLine("Added Behavior B");
    }
}

装饰模式的应用场景

装饰模式适用于以下情况：

需要动态地给对象添加额外的职责，而且这些职责可以被多次叠加。
使用继承扩展功能不太灵活，希望通过组合来扩展对象功能。
需要扩展一些无法修改其源码的类的功能。

装饰模式的优势

灵活性高： 装饰模式通过对象组合的方式，使得可以动态地扩展对象的功能，而无需修改其接口。
遵循开闭原则： 装饰模式允许在不修改已有代码的情况下，引入新的装饰器类，符合开闭原则。
可组合性： 可以通过不同的装饰器类组合出多种不同的行为组合，使得系统更具弹性和可扩展性。

使用示例

class Program
{
    static void Main()
    {
        // 创建具体组件对象
        ConcreteComponent component = new ConcreteComponent();

        // 创建具体装饰器对象A，并设置其包装的组件对象
        ConcreteDecoratorA decoratorA = new ConcreteDecoratorA();
        decoratorA.SetComponent(component);

        // 创建具体装饰器对象B，并设置其包装的组件对象
        ConcreteDecoratorB decoratorB = new ConcreteDecoratorB();
        decoratorB.SetComponent(decoratorA);

        // 调用装饰器对象的操作方法，实际上会动态调用所有包装的组件的操作方法
        decoratorB.Operation();
    }
}

总结

装饰模式是一种结构型设计模式，通过对象组合的方式，动态地扩

展对象的功能。装饰模式使得系统具备了更高的灵活性，能够在运行时动态地添加新的职责。在实际应用中，装饰模式常用于需要动态地扩展对象功能、而又不希望通过继承来实现的场景。

设计模式-结构型模式-享元模式

发表于 2023-12-09 更新于 2025-04-18 分类于架构思想

享元模式 - 结构型模式的轻量级共享

在软件设计中，享元模式是一种结构型设计模式，它通过共享对象来减小系统中对象的数量，从而提高系统的性能。本文将深入讨论享元模式的概念、实现方式以及在实际应用中的使用场景。

享元模式的概念

享元模式（Flyweight Pattern）是一种结构型设计模式，其核心思想是共享对象以减小系统中对象的数量。享元模式适用于大量相似对象的场景，通过共享内部状态，减小存储和对象创建的开销。

享元模式的 UML 类图

classDiagram
    class Flyweight {
        + Operation(state: int): void
    }

    class ConcreteFlyweight {
        + Operation(state: int): void
    }

    class UnsharedConcreteFlyweight {
        + Operation(state: int): void
    }

    class FlyweightFactory {
        - flyweights: Dictionary
        + GetFlyweight(key: int): Flyweight
    }

    Flyweight <|.. ConcreteFlyweight
    Flyweight <|.. UnsharedConcreteFlyweight
    FlyweightFactory --> Flyweight

享元模式的实现方式

using System;
using System.Collections.Generic;

// 抽象享元类
public abstract class Flyweight
{
    public abstract void Operation(int state);
}

// 具体享元类
public class ConcreteFlyweight : Flyweight
{
    public override void Operation(int state)
    {
        Console.WriteLine($"Concrete Flyweight Operation with state: {state}");
    }
}

// 不共享的具体享元类
public class UnsharedConcreteFlyweight : Flyweight
{
    public override void Operation(int state)
    {
        Console.WriteLine($"Unshared Concrete Flyweight Operation with state: {state}");
    }
}

// 享元工厂类
public class FlyweightFactory
{
    private Dictionary<int, Flyweight> flyweights = new Dictionary<int, Flyweight>();

    public Flyweight GetFlyweight(int key)
    {
        if (flyweights.ContainsKey(key))
        {
            return flyweights[key];
        }
        else
        {
            Flyweight flyweight = new ConcreteFlyweight();
            flyweights.Add(key, flyweight);
            return flyweight;
        }
    }
}

享元模式的应用场景

享元模式适用于以下情况：

系统中存在大量相似对象，占用大量内存。
对象的状态可以外部状态和内部状态，外部状态可以在对象被创建后进行修改。
系统中的对象可以被共享，且客户端可以忽略对象的具体状态。

享元模式的优势

减小内存占用： 享元模式通过共享内部状态，减小系统中对象的数量，从而减小内存占用。
提高性能： 由于减少了对象的数量，系统性能得到提升，特别在需要大量创建相似对象的场景中。
灵活性： 享元模式将对象的状态分为内部状态和外部状态，外部状态可以在对象被创建后进行修改，提高了灵活性。

使用示例

class Program
{
    static void Main()
    {
        // 创建享元工厂对象
        FlyweightFactory factory = new FlyweightFactory();

        // 获取共享的具体享元对象
        Flyweight flyweight1 = factory.GetFlyweight(1);

        // 调用具体享元对象的操作方法，实际上会共享相同的对象
        flyweight1.Operation(10);

        // 获取不共享的具体享元对象
        Flyweight flyweight2 = new UnsharedConcreteFlyweight();

        // 调用不共享的具体享元对象的操作方法
        flyweight2.Operation(20);
    }
}

总结

享元模式是一种结构型设计模式，通过共享内部状态以减小系统中对象的数量，提高系统性能。享元模式适用于大量相似对象的场景，通过共享内部状态，减小存储和对象创建的开销。在实际应用中，享元模式需要权衡共享状态和非共享状态的管理，确保系统的灵活性和可维护性。

设计模式-结构型模式-外观模式

发表于 2023-12-09 更新于 2025-04-18 分类于架构思想

外观模式 - 结构型模式的简化接口

在软件设计中，外观模式是一种结构型设计模式，它提供了一个统一的接口，用于访问系统中的一组接口。本文将深入讨论外观模式的概念、实现方式以及在实际应用中的使用场景。

外观模式的概念

外观模式（Facade Pattern）是一种结构型设计模式，其核心思想是提供一个简化的接口，用于访问系统中的一组接口。外观模式通过创建一个高层接口，将系统中的一组接口封装起来，使得客户端可以更容易地使用系统。

外观模式的 UML 类图

classDiagram
    class Facade {
        + Operation(): void
    }

    class SubsystemA {
        + OperationA(): void
    }

    class SubsystemB {
        + OperationB(): void
    }

    class SubsystemC {
        + OperationC(): void
    }

    Facade --> SubsystemA
    Facade --> SubsystemB
    Facade --> SubsystemC

外观模式的实现方式

using System;

// 子系统A
public class SubsystemA
{
    public void OperationA()
    {
        Console.WriteLine("Subsystem A Operation");
    }
}

// 子系统B
public class SubsystemB
{
    public void OperationB()
    {
        Console.WriteLine("Subsystem B Operation");
    }
}

// 子系统C
public class SubsystemC
{
    public void OperationC()
    {
        Console.WriteLine("Subsystem C Operation");
    }
}

// 外观类
public class Facade
{
    private SubsystemA subsystemA;
    private SubsystemB subsystemB;
    private SubsystemC subsystemC;

    public Facade()
    {
        subsystemA = new SubsystemA();
        subsystemB = new SubsystemB();
        subsystemC = new SubsystemC();
    }

    public void Operation()
    {
        subsystemA.OperationA();
        subsystemB.OperationB();
        subsystemC.OperationC();
    }
}

外观模式的应用场景

外观模式适用于以下情况：

需要为一个复杂的子系统提供一个简单的接口。
客户端与多个子系统之间存在复杂的依赖关系，而希望将这些依赖关系封装在一个统一的接口中。
希望将子系统和客户端之间的耦合度降到最低，使得系统更易于维护和扩展。

外观模式的优势

简化接口： 外观模式提供了一个简化的接口，使得客户端更容易使用系统。
解耦子系统： 外观模式将客户端与子系统解耦，减少了客户端与子系统之间的依赖关系。
提高灵活性： 外观模式使得系统更容易维护和扩展，通过修改外观类，而不是修改多个子系统的代码。

使用示例

class Program
{
    static void Main()
    {
        // 创建外观对象
        Facade facade = new Facade();

        // 调用外观对象的操作方法，实际上会调用多个子系统的操作方法
        facade.Operation();
    }
}

总结

外观模式是一种结构型设计模式，通过提供一个简化的接口，将系统中的一组接口进行封装，使得客户端更容易使用系统。外观模式常用于需要为复杂的子系统提供一个简单接口、或者降低客户端与子系统之间耦合度的情景。在实际应用中，外观模式能够有效地提高系统的可维护性、可扩展性和灵活性。

设计模式-结构型模式-适配器模式

发表于 2023-12-09 更新于 2025-04-18 分类于架构思想

适配器模式 - 结构型模式的接口转换魔法

在软件设计中，适配器模式是一种结构型设计模式，它允许将一个类的接口转换为客户端期望的另一个接口。本文将深入讨论适配器模式的概念、实现方式以及在实际应用中的使用场景。

适配器模式的概念

适配器模式（Adapter Pattern）是一种结构型设计模式，它允许将一个类的接口转换为客户端期望的另一个接口。适配器使得原本因接口不匹配而无法一起工作的类可以一起工作。

适配器模式的 UML 类图

classDiagram
    class Target {
        + Request(): void
    }

    class Adaptee {
        + SpecificRequest(): void
    }

    class Adapter {
        - adaptee: Adaptee
        + Request(): void
    }

    Target <|.. Adapter
    Adaptee <|.. Adapter

适配器模式的实现方式

using System;

// 目标接口
public interface Target
{
    void Request();
}

// 源接口
public class Adaptee
{
    public void SpecificRequest()
    {
        Console.WriteLine("Adaptee's specific request");
    }
}

// 适配器
public class Adapter : Target
{
    private readonly Adaptee adaptee;

    public Adapter(Adaptee adaptee)
    {
        this.adaptee = adaptee;
    }

    public void Request()
    {
        adaptee.SpecificRequest();
    }
}

适配器模式的应用场景

适配器模式适用于以下情况：

需要使用一个已经存在的类，但其接口不符合系统的需求。
需要创建一个可以复用的类，与其他不相关的类或不可预见的接口协同工作。
需要使用一些已经存在的子类，但不可能对每个子类进行适配。

适配器模式的优势

解耦性强： 适配器模式将目标类和适配者类解耦，使得它们可以独立变化，增强了系统的灵活性。
复用性好： 已经存在的类可以在适配器中被复用，无需修改原有代码。
扩展性强： 在不修改适配者和目标类的前提下，可以增加新的适配器类，扩展系统的功能。

使用示例

class Program
{
    static void Main()
    {
        // 创建适配者对象
        Adaptee adaptee = new Adaptee();

        // 创建适配器对象，并将适配者对象传入
        Target adapter = new Adapter(adaptee);

        // 客户端通过目标接口调用适配器的方法
        adapter.Request();
    }
}

总结

适配器模式的意图就是通过接口转换，使本来不兼容的接口可以协作。一次适配也许不能满足我们的需要，项目中我们往往需要做适配器间的互联，随着XML数据的广泛使用，我们还需要专门的适配器设计思路。

适配器模式是一种结构型设计模式，通过将一个类的接口转换为另一个接口，使得原本不兼容的类可以一起工作。适配器模式在实际应用中常用于整合已有的系统，提供统一的接口。在设计中，适配器模式需要权衡代码的灵活性和复杂性，确保达到适配的同时不引入过多的代码复杂性。