## 引言
**观察者模式**是一种行为型设计模式，它允许对象之间建立一种一对多的关系，使得当一个对象状态改变时，所有依赖它的对象都能够自动得到通知并更新自己的状态。该模式可以帮助我们实现松耦合的系统，以便更好地应对变化和扩展。


在观察者模式中，有两个角色：**观察者**和**被观察者**。被观察者负责维护观察者列表，并在状态发生改变时通知观察者；观察者则负责接收被观察者的通知并进行相应的处理。

下面我们通过一个简单的例子来说明观察者模式的用法。假设我们要实现一个计数器，每次计数器增加时需要通知所有的观察者。

### 观察者

先定义一个接口`IObserver`，用于定义观察者的行为，该接口只有一个方法`Update`，用于接收被观察者的通知并更新观察者的状态。

```csharp
public interface IObserver
{
    void Update(int count);
}
```
再定义一个观察者实现`ConsoleObserver`，它负责在控制台上输出计数器的值。

```csharp
public class ConsoleObserver : IObserver
{
    public void Update(int count)
    {
        Console.WriteLine($"Count = {count}");
    }
}

```


### 被观察者
定义一个被观察者`Counter`，它负责维护观察者列表，并在计数器增加时通知观察者。

```csharp
public class Counter
{
    private int count = 0;
    private List<IObserver> observers = new List<IObserver>();

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

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

    public void Increment()
    {
        count++;
        NotifyObservers();
    }

    private void NotifyObservers()
    {
        foreach (IObserver observer in observers)
        {
            observer.Update(count);
        }
    }
}
```

然后可以定义一个观察者`ConsoleObserver`，一个被观察者`Counter`,再计数器增加时，通知`ConsoleObserver`输出到控制台。

```csharp
Counter counter = new Counter();

IObserver consoleObserver = new ConsoleObserver();

counter.AddObserver(consoleObserver);

counter.Increment();
```
控制台得到输出`Count = 1`。

## 结论
观察者模式广泛应用于GUI（图形用户界面）开发、事件驱动系统、消息通知系统、进程间通信等场景中。

它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，当主题对象发生变化时，所有依赖于它的观察者对象都会得到通知并自动更新。

观察者模式的作用是将系统中的关注点分离，提高系统的可维护性、扩展性和重用性。通过该模式，主题对象和观察者对象之间的耦合度降低，让它们之间的关系更加松散，从而使系统更加灵活、可扩展和易于维护。

重温设计模式 --- 观察者模式

## 引言
**单例模式**是一种创建型设计模式，它的主要目的是确保某个类在应用程序中只有一个实例，并且这个实例能够被全局访问。在许多情况下，单例模式是非常有用的，比如说当你需要创建一个全局的配置类或者日志类时，单例模式可以让你轻松地实现这些功能。

在实现单例模式时，有两种常见的方法，“懒汉式”和“饿汉式”

### 懒汉式


```csharp
public class Singleton
{
    private static Singleton instance;
    
    private Singleton()
    {
        // 私有构造函数
    }
    
    public static Singleton GetInstance()
    {
        if(instance == null)
        {
            instance = new Singleton();
        }
        return instance;
    }
}

```

这种方式的特点是只有在需要的时候才会创建实例，而不是在类加载的时候就创建实例。这种方式可以节省系统资源，但是可能会影响性能。


### 懒汉式（双检锁）

上文中的实现方案中，并未考虑到线程安全，要确保在多线程环境下只有一个实例被创建，需要**使用双重检查锁定**，双检锁/双重校验锁（DCL，即 double-checked locking）。

```csharp
public class Singleton
{
    private static Singleton instance;
    private static readonly object lockObject = new object();

    private Singleton()
    {
        // 私有构造函数
    }

    public static Singleton GetInstance()
    {
        if (instance == null)
        {
            lock (lockObject)
            {
                if (instance == null)
                {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

```
### 饿汉式


```csharp
public class Singleton
{
    private static Singleton instance = new Singleton();
    
    private Singleton()
    {
        // 私有构造函数
    }
    
    public static Singleton GetInstance()
    {
        return instance;
    }
}

```

这种方式的特点是在类加载的时候就创建实例，而不是在需要的时候才创建实例。这种方式可以保证线程安全，但是可能会浪费系统资源。

在使用“饿汉式”方式实现单例模式时，实例是在类加载时创建的。因此，不需要使用额外的线程安全技术。

## 总结
总的来说，单例模式是一种常见的设计模式，它能够确保某个类在应用程序中只有一个实例，并且这个实例能够被全局访问。但在使用“懒汉式”实现时，要注意线程安全问题。

重温设计模式 --- 单例模式

## 引言
**抽象工厂模式**一种创建型设计模式，它提供了一种方式来封装一组具有相同主题的工厂，而不必指定它们具体的类。这样，客户端代码就可以使用抽象工厂来创建一组相关的对象，而不必关心实际创建的具体类。


抽象工厂模式有以下几个主要角色：
- 抽象工厂（AbstractFactory）：声明用于创建抽象产品的操作的接口。

- 工厂实现（ConcreteFactory）：实现创建具体产品对象的操作。

- 抽象产品（AbstractProduct）：声明产品对象类型的接口。

- 产品实现（Product）：定义由相应的具体工厂创建的产品对象，实现AbstractProduct接口。

下面使用C#实现抽象工厂模式:

### 抽象工厂
定义一个抽象工厂接口，其中包含了创建不同产品的方法：
```csharp
public interface IAbstractFactory
{
    IProductA CreateProductA();
    IProductB CreateProductB();
}

```
### 工厂实现
定义具体的工厂类，实现抽象工厂接口：
```csharp
public class ConcreteFactory1 : IAbstractFactory
{
    public IProductA CreateProductA()
    {
        return new ConcreteProductA1();
    }

    public IProductB CreateProductB()
    {
        return new ConcreteProductB1();
    }
}

public class ConcreteFactory2 : IAbstractFactory
{
    public IProductA CreateProductA()
    {
        return new ConcreteProductA2();
    }

    public IProductB CreateProductB()
    {
        return new ConcreteProductB2();
    }
}

```
在上述示例中，我们定义了两个具体工厂类：`ConcreteFactory1`和`ConcreteFactory2`。这两个工厂类都实现了`IAbstractFactory`接口，并且分别提供了不同的产品实现。
### 抽象产品
```csharp
public interface IProductA
{
    string GetName();
}
```
### 产品实现
```csharp
public class ConcreteProductA1 : IProductA
{
    public string GetName()
    {
        return "ProductA1";
    }
}

public class ConcreteProductA2 : IProductA
{
    public string GetName()
    {
        return "ProductA2";
    }
}

public interface IProductB
{
    string GetName();
}

public class ConcreteProductB1 : IProductB
{
    public string GetName()
    {
        return "ProductB1";
    }
}

public class ConcreteProductB2 : IProductB
{
    public string GetName()
    {
        return "ProductB2";
    }
}
```

下面，我们可以使用抽象工厂来创建一组相关的对象：

```csharp
public class Client
{
    private IAbstractFactory factory;

    public Client(IAbstractFactory factory)
    {
        this.factory = factory;
    }

    public void Run()
    {
        var productA = factory.CreateProductA();
        var productB = factory.CreateProductB();

        Console.WriteLine(productA.GetName());
        Console.WriteLine(productB.GetName());
    }
}

static void Main(string[] args)
{
    var client1 = new Client(new ConcreteFactory1());
    client1.Run();

    var client2 = new Client(new ConcreteFactory2());
    client2.Run();
}
```
输出：

```csharp
ProductA1
ProductB1

ProductA2
ProductB2
```

## 总结

上面的示例中，我们使用抽象工厂模式来创建了一组相关的对象，但是需要注意的是，它适用于创建一组相关的产品对象，但是当产品族的变化引起整个工厂等级结构的变化时，抽象工厂模式就不适用了。

此外，抽象工厂模式还存在一些缺点，例如：
- 新增产品会导致工厂接口的扩展。如果需要新增产品，就需要修改所有的工厂类，这会带来一些不必要的麻烦。

- 可能会导致类层次结构的复杂度增加。如果有多个产品族，就需要定义多个工厂接口，这会增加类层次结构的复杂度。

因此，在使用抽象工厂模式时，需要根据具体情况进行权衡和选择。

重温设计模式 --- 抽象工厂模式

## 引言
SOLID是五个常见的面向对象设计原则的缩写，其目的是帮助开发者设计易于维护和扩展的软件系统

其中包含**单一职责原则(SRP)**，**开闭原则(OCP)**，**里氏替换原则(LSP)**，**接口隔离原则(ISP)**，**依赖反转原则(DIP)**。

除SOLID之外，后续又增加了**迪米特法则**。



## 单一职责原则

**单一职责原则（Single Responsibility Principle，SRP）**，这个原则指出一个类应该只有一个职责。也就是说，一个类应该只有一种修改的原因。如果一个类负责多个不同的职责，那么对其中一个职责的修改可能会影响到其他职责，从而导致系统的不稳定性。

## 开闭原则

**开闭原则（Open-Closed Principle，OCP）**，这个原则指出一个类应该对扩展开放，对修改关闭。也就是说，系统中的类应该能够方便地进行扩展，但是对于已经存在的类，尽量避免进行修改。这样可以减少代码的复杂性，提高系统的稳定性。



:::tip{title="提示"}
开闭原则需要避免过度设计，即在不必要的情况下进行扩展。同时，应该避免使用复杂的继承结构，而应该优先使用组合和接口实现扩展。
:::

## 里氏替换原则

**里氏替换原则（Liskov Substitution Principle，LSP）**，这个原则指出，如果一个子类不能完全替代它的父类，那么这个子类就不应该存在。换句话说，子类应该能够在不影响父类的前提下，完全替代父类的功能。这样才能保证系统的正确性和稳定性。



:::tip{title="提示"}
里氏替换原则需要注意继承关系的正确性。子类必须要遵循父类的约束，否则就会破坏LSP的原则。同时，在使用多态时需要注意类型的转换和类型检查的正确性。
:::

## 接口隔离原则

**接口隔离原则（Interface Segregation Principle，ISP）**，这个原则指出一个类不应该强制依赖它不需要的接口。如果一个类依赖了一个过于庞大的接口，那么当这个接口发生变化时，这个类也需要相应地进行修改。因此，一个类应该尽量只依赖于它需要的接口，避免不必要的依赖。

:::tip{title="提示"}
接口隔离原则需要避免接口的冗余和重复。接口应该根据不同的职责进行分离，避免一个接口承担过多的职责。同时，应该避免使用过于具体的接口，而应该优先使用更抽象的接口
:::

## 依赖反转原则

**依赖反转原则（Dependency Inversion Principle，DIP）**，这个原则指出，高层模块不应该依赖于低层模块，两者都应该依赖于抽象。同时，抽象不应该依赖于具体实现，具体实现应该依赖于抽象。这样可以减少系统的耦合度，提高系统的可扩展性和可维护性。

:::tip{title="提示"}
依赖反转原则需要注意依赖注入的方式和依赖倒置的层次。依赖注入应该使用构造函数注入、属性注入或方法注入，避免使用硬编码的依赖。同时，在依赖倒置时需要注意依赖的层次，避免高层模块依赖过于低层的模块。
:::

## 迪米特法则
**迪米特法则(Law of Demeter,LoD)也称为最少知识原则(Least Knowledge Principle,LKP)**。
迪米特法则要求一个对象应该只与其直接的朋友通信，而不是跟朋友的朋友或者更远的对象通信。对象之间的耦合度越低，系统的灵活性、可维护性、可扩展性就越好，同时也降低了代码的复杂度和风险。
:::tip{title="提示"}
迪米特法则需要注意：
- 将方法中的参数尽量缩小，尽量不引入不需要的对象。
- 在类的设计中，尽量降低对其他类的依赖。
- 将依赖其他类的操作放到一个中介类中，由中介类负责和其他类的通信。
:::

## 结论

SOLID原则是一种很好的软件设计指导原则，能够帮助开发者设计出易于维护和扩展的软件系统。但是，这些原则并不是银弹，需要根据具体的情况进行灵活运用。同时，在应用这些原则时需要注意细节和实现细节，才能真正达到SOLID原则的设计目标。

设计原则 --- SOLID

## 引言

### AOP
**AOP（Aspect-Oriented Programming）** 编程思想是一种面向切面编程的编程范式。在日常的软件开发中，我们经常会遇到一些**横切关注点（cross-cutting concerns）**，如`日志记录`、`事务处理`、`权限控制`、`异常处理`等。这些横切关注点可能会存在于程序的多个模块中，使得程序的不同模块之间存在较强的耦合性，从而影响了程序的可维护性和可扩展性。AOP编程思想的目的就是将这些横切关注点从程序的业务逻辑中剥离出来，并将其模块化处理，从而提高程序的可维护性和可扩展性。


 
### 切面
在AOP编程思想中，切面（aspect）是指横切关注点的抽象概念，它通常用一个类或一个模块来表示。切面通过将横切关注点的代码封装到独立的模块中，使得这些代码可以在程序的不同模块之间共享和复用。切面通过定义切点（pointcut）和通知（advice）来实现对横切关注点的处理。

### 切点
切点定义了哪些代码片段需要被处理，通知则定义了在切点处执行的处理逻辑。在AOP编程中，通知可以分为前置通知（before advice）、后置通知（after advice）、环绕通知（around advice）等不同类型，具体使用哪种类型的通知取决于需要实现的功能。

## AOP 的优缺点

### 优点
1. **解耦**：AOP编程将横切关注点从业务逻辑中分离出来，使得程序各个模块之间的依赖关系降低，从而实现了解耦。
2. **复用**：AOP编程将横切关注点封装到独立的模块中，使得这些代码可以在程序的不同模块之间共享和复用。
3. **可维护性**：AOP编程将横切关注点的处理逻辑从业务逻辑中分离出来，使得程序的各个模块更加简单，易于维护。
4. **可扩展性**：AOP编程通过切面的定义和配置，可以很容易地扩展系统的功能，而不需要对原有的业务逻辑进行修改。

### 缺点
1. **增加复杂性**：AOP编程将程序的逻辑分散到多个模块中，增加了程序的复杂性，对于一些小规模的项目可能会显得过于复杂。
2. **难以调试**：由于横切关注点的代码可能被多个模块共享，所以在调试时可能会比较困难。

AOP编程思想增加了程序的复杂性，难以调试等。但总体来说，AOP编程思想对于大型软件系统的开发和维护是非常有用的。它可以使得程序的结构更加清晰、易于维护和扩展，同时也可以提高程序的重用性和可测试性。使用AOP编程思想可以让开发人员更加专注于业务逻辑的实现，而将横切关注点的处理交给AOP框架去处理，从而提高开发效率和代码质量。

## C# 利用AutoFac实现简单AOP

接下来我们借助`反射`，`Attribute`,三方容器`AutoFac`，实现一个简单AOP：

### 1. 创建动态代理

```csharp
    internal class DynamicProxy<T> : DispatchProxy
    {
        public T? decorated { get; set; }//目标类
        
        public Action<object?[]?>? _BeforeAction { get; set; } // 动作之前执行
        
        public Action<object?[]?, object>? _AfterAction { get; set; }  // 动作之后执行
        
        public Action<Exception>? _CatchExceptionAction { get; set; }  // 捕获异常之后执行

        protected override object? Invoke(MethodInfo? targetMethod, object?[]? args)
        {
            Exception exception = null;

            Before(args);

            object result = null;
            try
            {
                //调用实际目标对象的方法
                result = targetMethod?.Invoke(decorated, args);
            }
            catch (Exception ex)
            {
                exception = ex;
            }

            After(args, result);

            //调用完执行方法后的委托，如果有异常，抛出异常
            if (exception != null)
            {
                CatchException(exception);
            }
            return result;
        }

        /// <summary>
        /// 创建代理实例
        /// </summary>
        /// <param name="decorated">代理的接口类型</param>
        /// <param name="beforeAction">方法执行前执行的事件</param>
        /// <param name="afterAction">方法执行后执行的事件</param>
        /// <param name="catchException">异常捕获后执行的事件</param>
        /// <returns></returns>
        public T Create(T decorated, Action<object?[]?> beforeAction, Action<object?[]?, object> afterAction, Action<Exception> catchException)
        {
            // 调用DispatchProxy 的Create  创建一个新的T
            object proxy = Create<T, DynamicProxy<T>>();

            DynamicProxy<T> proxyDecorator = (DynamicProxy<T>)proxy;

            proxyDecorator.decorated = decorated;

            //把自定义的方法委托给代理类
            proxyDecorator._AfterAction = afterAction;

            proxyDecorator._BeforeAction = beforeAction;

            proxyDecorator._CatchExceptionAction = catchException;

            return (T)proxy;
        }

        private void Before(object?[]? args)
        {
            try
            {
                _BeforeAction.Invoke(args);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"执行之前异常：{ex.Message}");
            }
        }

        private void After(object?[]? args, object? result)
        {
            try
            {
                _AfterAction.Invoke(args, result);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"执行之后异常：{ex.Message}");
            }
        }

        private void CatchException(Exception ex)
        {
            _CatchExceptionAction(ex);
        }
    }
```
### 2. 创建拦截器属性
标记AOP切点的**Attribute--InterceptAttribut**(拦截器属性)

```csharp
    /// <summary>
    /// 自定义拦截器特性
    /// </summary>
    [AttributeUsage(AttributeTargets.Class)]
    internal class InterceptAttribut : Attribute
    {
        public Type Type { get; set; }
        public InterceptAttribut(Type type)
        {
            this.Type = type;
        }
    }
```


### 3. 创建动态代理工厂类
它是泛型工厂,用于创建不同类型的代理类

```csharp
    class DynamicProxyFactory
    {
        /// <summary>
        /// 创建代理实例
        /// </summary>
        /// <param name="decorated">代理的接口类型</param>
        /// <returns></returns>
        public static T Create<T>()
        {
            var decorated = ServiceHelp.GetService<T>(typeof(T));
            
            var type = decorated.GetType();
            
            var interceptAttribut = type.GetCustomAttribute<InterceptAttribut>();
            
            var interceptor = ServiceHelp.GetService<IInterceptor>(interceptAttribut.Type);
            //创建代理类
            var proxy = new DynamicProxy<T>().Create(decorated, interceptor.BeforeExecuted, interceptor.AfterExecuted, interceptor.CatchException);
            
            return proxy;
        }
    }
```
### 4. 创建ServiceHelp
ServiceHelp用于获取实例,其核心就是以Autofac这个IOC容器去注册及获取服务.

```csharp
    internal class ServiceHelp
    {
        //实例化Autofac容器
        private static ContainerBuilder builder = new ContainerBuilder();

        public static IContainer? serviceProvider { get; set; }

        public static void BuildServiceProvider()
        {
            //注册InstanceModule组件
            builder.RegisterModule<InstanceModule>();
            //创建容器
            serviceProvider = builder.Build();
        }

        internal static T GetService<T>(Type serviceType)
        {
            if (serviceProvider.IsRegistered(serviceType))
            {
                return (T)serviceProvider.Resolve(serviceType);
            }
            return default(T);
        }
    }
```
### 5. 创建AOP切面

```csharp
    /// <summary>
    /// 自定义拦截器接口
    /// </summary>
    interface IInterceptor
    {
        /// <summary>
        /// 执行前
        /// </summary>
        /// <param name="args"></param>
        void BeforeExecuted(object?[]? args);
        /// <summary>
        /// 执行后
        /// </summary>
        /// <param name="args">参数</param>
        /// <param name="result">返回值</param>
        void AfterExecuted(object?[]? args, object? result);

        void CatchException(Exception ex);

    }
    /// <summary>
    /// 方法执行的切面
    /// </summary>
    class ExecutAOP : IInterceptor
    {
        public void AfterExecuted(object?[]? args, object? result)
        {
            Console.WriteLine($"拦截器中方法后执行~~~~");
        }

        public void BeforeExecuted(object?[]? args)
        {
            if (args != null && args.Length > 0 && args[0] == null)
                throw new Exception("参数错误");
            Console.WriteLine($"拦截器中方法前执行~~~~");

        }
        public void CatchException(Exception ex)
        {
            Console.WriteLine($"拦截器中捕获到了异常~~~~\r\n{ex.InnerException.Message}");
        }
    }
```
### 6. 创建测试模型
设定一个业务场景,有一个交通工具`ITransportation`有两个公共方法` Run()` 、`Eat()`,以及其实现`Hours`类
```csharp
    interface ITransportation
    {
        public void Run();
        
        public void Eat(string food);
    }

    [InterceptAttribut(typeof(ExecutAOP))]
    class Horse : ITransportation
    {
        public void Eat(string food)
        {
            Console.WriteLine($"小马儿吃了{food}~~~~~~~~~~~~");
        }

        public void Run()
        {
            Console.WriteLine("马儿马儿快马加鞭~~~~~~~~~~~~");
            throw new Exception("小马儿掉沟里了");
        }
    }
```
### 7.测试场景

1. 测试切面方法执行前和执行后

    
```csharp
    static void Main(string[] args)
    {
        ServiceHelp.BuildServiceProvider();

        var hours = DynamicProxyFactory.Create<ITransportation>();

        hours.Eat("新鲜牧草");

        Console.ReadLine();
    }

```
输出:

![image.png](https://niuery.com/static/img/bcace5bd480606ac5fb97bc4b7c3bb7e.image.png)

从控制台输出可以看到，`Horse`再执行`Eat`方法前和方法后都被拦截，并输出了预期结果

2. 测试切面方法异常处理
```csharp
    static void Main(string[] args)
    {
        ServiceHelp.BuildServiceProvider();

        var hours = DynamicProxyFactory.Create<ITransportation>();

        hours.Run();

        Console.ReadLine();
    }

```
输出:

![image.png](https://niuery.com/static/img/4c115bd6a04fd809bc1148e2eace0ee1.image.png)
再`Horse`的`Run`方法中我们主动抛出了异常，然后从控制台输出可以看到，异常也被拦截器拦截，并做了处理输出`拦截器中捕获到了异常`及异常信息。

## 总结
总之，AOP编程思想是一种非常有用的编程范式，它可以使得程序的结构更加清晰、易于维护和扩展，同时也可以提高程序的重用性和可测试性。在日常的软件开发中，我们可以使用AOP框架来实现AOP编程思想，从而提高开发效率和代码质量。