【23种设计模式+六大设计原则】C#零基础到入门，点亮你的编程新世界

前端

2023-11-12 14:42:38

C# 设计模式：构建灵活性、可维护性和可重用性的软件

作为一名 C# 程序员，掌握设计模式对于构建健壮且优雅的代码至关重要。这些模式提供了一种经过验证的方法来解决常见的编程问题，从而使你的代码更具适应性、易于维护和高度可重用。

23 种设计模式：应对各种编程挑战

C# 中存在着广泛的设计模式，分为三类：创建型、结构型和行为型。

创建型模式：

工厂方法：创建一个对象的实例，而无需指定其确切类型。
抽象工厂：提供一个接口来创建相关或依赖的对象，而无需指定它们的具体类型。
单例：确保一个类只有一个实例，并提供一个全局访问点。
原型：通过复制现有对象来创建新对象，而不是重新创建它们。
建造者：将复杂对象的构建与它的表示分离。

结构型模式：

适配器：允许两个不兼容的接口进行交互。
桥接：将抽象部分与实现部分解耦，使它们能够独立变化。
组合：将对象组合成树形结构，表示部分与整体之间的层次关系。
装饰器：动态地向对象添加新功能，而无需更改其结构。
外观：为子系统提供一个统一的接口，简化客户端与子系统之间的交互。
代理：为另一个对象提供一个代理或替身，以控制对该对象的访问。

行为型模式：

策略：将算法的家族封装起来，使它们可以互换，客户端可以动态地选择不同的算法。
观察者：允许对象在不知道其他对象的情况下依赖它们，以便在对象状态更改时通知所有依赖对象。
模板方法：定义操作的算法骨架，同时将某些步骤延迟到子类中。
命令：将请求封装成一个对象，以便使用不同的请求队列或日志来参数化其他对象。
迭代器：提供一种方法来访问集合中的元素，而无需公开集合的内部表示。
职责链：将请求的处理链分解成一系列较小的处理步骤，并允许请求在这些步骤之间传递。
状态：允许对象在内部状态更改时更改其行为。
访问者：允许你定义一个新操作，以便在对象结构上执行，而无需更改这些对象的类。

6 大设计原则：构建坚实的基础

除了这些模式，理解六大设计原则对于构建高质量代码也很重要：

单一职责：每个类应只承担单一职责。
开闭：软件实体应向扩展开放，但向修改关闭。
里氏代换：子类对象可以替换父类对象，而不会破坏程序正确性。
接口隔离：客户端不应依赖它们不使用的方法。
依赖倒置：高层模块不应依赖低层模块，两者都应依赖抽象。
合成复用：尽可能使用合成/聚合而不是继承来实现代码复用。

C# 设计模式代码示例

工厂方法：

public interface IProduct
{
    string GetName();
}

public class ConcreteProductA : IProduct
{
    public string GetName()
    {
        return "ProductA";
    }
}

public class ConcreteProductB : IProduct
{
    public string GetName()
    {
        return "ProductB";
    }
}

public class Factory
{
    public IProduct CreateProduct(string productType)
    {
        switch (productType)
        {
            case "A":
                return new ConcreteProductA();
            case "B":
                return new ConcreteProductB();
            default:
                throw new Exception("Invalid product type.");
        }
    }
}

观察者：

public interface ISubject
{
    void Attach(IObserver observer);
    void Detach(IObserver observer);
    void Notify();
}

public interface IObserver
{
    void Update(ISubject subject);
}

public class Subject : ISubject
{
    private List<IObserver> _observers = new List<IObserver>();
    private int _state;

    public int State
    {
        get { return _state; }
        set
        {
            _state = value;
            Notify();
        }
    }

    public void Attach(IObserver observer)
    {
        Console.WriteLine("Subject: Attached an observer.");
        _observers.Add(observer);
    }

    public void Detach(IObserver observer)
    {
        _observers.Remove(observer);
        Console.WriteLine("Subject: Detached an observer.");
    }

    public void Notify()
    {
        Console.WriteLine("Subject: Notifying observers...");
        foreach (var observer in _observers)
        {
            observer.Update(this);
        }
    }
}

public class ObserverA : IObserver
{
    public void Update(ISubject subject)
    {
        if ((subject as Subject).State < 3)
        {
            Console.WriteLine("ObserverA: Reacted to the event.");
        }
    }
}

public class ObserverB : IObserver
{
    public void Update(ISubject subject)
    {
        if ((subject as Subject).State == 0 || (subject as Subject).State >= 3)
        {
            Console.WriteLine("ObserverB: Reacted to the event.");
        }
    }
}