观察者，装饰，策略模式

观察者模式（Observer Pattern）

1. 简述观察者模式的概念和应用场景
   • 观察者模式定义了一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都会得到通知并自动更新。
   • 应用场景包括事件处理系统（如按钮点击事件通知多个监听器）、股票价格变化通知多个投资者等。
2. 在 C# 中实现观察者模式

 

using System;
using System.Collections.Generic;

// 观察者接口
public interface IObserver
{
    void Update(string message);
}

// 主题接口
public interface ISubject
{
    void Attach(IObserver observer);
    void Detach(IObserver observer);
    void Notify(string message);
}

// 具体主题类
public class ConcreteSubject : ISubject
{
    private List<IObserver> observers = new List<IObserver>();

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

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

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

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

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

    public void Update(string message)
    {
        Console.WriteLine($"{name} received message: {message}");
    }
}

 

3. 分析观察者模式的优缺点
   • 优点：实现了对象之间的松散耦合，主题和观察者可以独立变化；可以方便地增加或删除观察者。
   • 缺点：如果观察者过多，通知所有观察者会花费较多时间；如果观察者和主题之间存在循环依赖，可能会导致系统崩溃。

装饰器模式（Decorator Pattern）

 

1. 简述装饰器模式的作用和应用场景
   • 装饰器模式允许向一个现有的对象添加新的功能，同时又不改变其结构。它通过将对象包装在装饰器类中，动态地扩展对象的功能。
   • 应用场景包括给图形添加边框、阴影等效果，给文件流添加加密、压缩等功能。
2. 在 C# 中实现装饰器模式

// 组件接口
public interface IComponent
{
    void Operation();
}

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

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

    public Decorator(IComponent component)
    {
        this.component = component;
    }

    public virtual void Operation()
    {
        component.Operation();
    }
}

// 具体装饰器类
public class ConcreteDecorator : Decorator
{
    public ConcreteDecorator(IComponent component) : base(component)
    {
    }

    public override void Operation()
    {
        base.Operation();
        Console.WriteLine("ConcreteDecorator additional operation");
    }
}

3. 装饰器模式与继承的区别
   • 装饰器模式是一种动态扩展对象功能的方式，它通过组合的方式将装饰器类和组件类组合在一起，在运行时可以灵活地添加或删除功能。
   • 继承是一种静态扩展对象功能的方式，在编译时就确定了子类的功能，一旦继承关系确定，就很难在运行时改变子类的功能。装饰器模式比继承更灵活，避免了继承带来的类爆炸问题。

策略模式（Strategy Pattern）

 

1. 简述策略模式的定义和应用场景
   • 策略模式定义了一系列的算法，并将每个算法封装起来，使它们可以相互替换。策略模式让算法的变化独立于使用算法的客户端。
   • 应用场景包括排序算法的选择（可以根据不同的需求选择冒泡排序、快速排序等）、支付方式的选择（如支付宝支付、微信支付、银行卡支付等）。
2. 在 C# 中实现策略模式

// 策略接口
public interface IStrategy
{
    int Execute(int a, int b);
}

// 具体策略类
public class AddStrategy : IStrategy
{
    public int Execute(int a, int b)
    {
        return a + b;
    }
}

public class SubtractStrategy : IStrategy
{
    public int Execute(int a, int b)
    {
        return a - b;
    }
}

// 上下文类
public class Context
{
    private IStrategy strategy;

    public Context(IStrategy strategy)
    {
        this.strategy = strategy;
    }

    public int ExecuteStrategy(int a, int b)
    {
        return strategy.Execute(a, b);
    }
}

策略模式如何提高代码的可维护性和可扩展性
可维护性：将不同的算法封装在独立的策略类中，每个策略类只负责自己的算法逻辑，代码结构清晰，便于修改和维护。
可扩展性：如果需要添加新的算法，只需创建一个新的策略类并实现策略接口，然后在上下文中使用新的策略类即可，无需修改现有的代码，符合开闭原则。