基于 Roslyn 的 AOP 切面拦截器

每一个编程小白，都有一个自己喜欢的小目标，我的小目标就是，写一个自己的 AOP 拦截器。

第一次用 PostSharp AOP 框架，感觉好神奇，怎么一个特性标记，方法就可以拦截了，好奇妙呀！所以一直心心念念想实现自己的 AOP 框架。

先后了解了一些 AOP 原理，大部分都是基于 IL 静态注入的（在编译时进行的代码注入），这个对于普通开发者来说，
学习成本有点高，所以自己基于 Roslyn 及 .NET DispatchProxy 代理来实现了一个 AOP 切面拦截器。

源代码：https://gitee.com/lan-xiaofang/roslyn-proxy.git/

参考文献：
Roslyn 也叫 .NET Compiler Platform SDK: https://learn.microsoft.com/zh-cn/dotnet/csharp/roslyn-sdk/
学习 C# 语法树，语义模型，代码自动生成，代码注入到执行上下文。

Roslyn 示例：https://github.com/dotnet/roslyn/blob/main/docs/features/source-generators.cookbook.md/
学习如何打包代码生成项目。

要了解代理模式

为什么要学代理模式？代理模式是 AOP 实现中常用的一种技术手段。

静态代理


// 1. 先定义一个接口和日志类型
public class IMyService{
    void Show();
}

public class Logger{
    static void Info(string info){
        Console.WriteLine(info)
    }
}

// 2. 然后定义一个基础服务 MyService
public class MyService : IMyService{
    public void Show(){
        Console.WriteLine("Hello!");
    }
}

// 2. 然后使用 MyServiceProxy 代理 IMyService 的实例
public class MyServiceProxy : IMyService{

    private readonly IMyService _service;

    public MyServiceProxy(IMyService service){
        _service = service;
    }

    public void Show(){
       try{
         Logger.Info("我要开始执行 Show 方法了...")
        _service.Show();
         Logger.Info("Show 方法顺利完成了!")
       }
       catch(ex){
        // 记录
        Logger.info(ex.ToString())
       }
    }
}

IMyService proxy = MyServiceProxy(new MyService());

// 3. 此时 MyServiceProxy 代理了 MyService
proxy.Show();

// 这就是一个简单的静态代理。。。

动态代理

动态代理，就是在运行时，根据我们的业务参数，动态的选择我们所需的代理实例。
例如：

// 1. 创建接口
public interface IMyInterface{

}

// 2. 创建接口类型1
public interface MyInterface1 : IMyInterface{

}

// 3. 创建接口类型2
public interface MyInterface2 : IMyInterface{

}

// 4. 创建 MyInterface1 的代理
class MyInterface1Proxy : IMyInterface{

    public MyInterface1Proxy(IMyInterface i){

    }
}

// 5. 创建 MyInterface2 的代理
class MyInterface2Proxy : IMyInterface{

    public MyInterface1Proxy(IMyInterface i){
        
    }
}

// 6. 代理工厂，在运行时，根据 IMyInterface 的实例类型，动态创建代理实例
public class ProxyFactory{
    public IMyInterface GetProxy(IMyInterface i){
        if (i is MyInterface1){
            return MyInterface1Proxy(i);
        }
        else
        if (i is MyInterface2){
            return MyInterface2Proxy(i)
        }
        throw new InvalidOpeartion();
    }
}

// 7. 根据接口实例，动态创建代理类型
var factory = new ProxyFactory();
IMyInterface proxy1 = factory.GetProxy(new MyInterface1()); // 返回 MyInterface1Proxy 的实例
IMyInterface proxy2 = factory.GetProxy(new MyInterface2()); // 返回 MyInterface2Proxy 的实例

为什么要使用 AOP 呢？

面向切面编程（AOP，Aspect-Oriented Programming）是一种编程范式，它通过将横切关注点（如日志、事务、安全等）从业务逻辑中分离出来，并以“切面”的形式进行管理和维护，从而提高了代码的模块性、可重用性和可维护性。使用AOP的主要原因包括：

模块化：通过将关注点与业务逻辑分离，AOP使得代码更加模块化，便于重用和维护。
松耦合：AOP降低了不同模块之间的耦合性，使得系统更加灵活和可扩展。
代码重用：AOP提高了代码的重用性，减少了代码的冗余。
提高开发效率：AOP通过提供声明式的方式来配置切面，使得开发者可以更快地实现横切关注点。
增强系统可维护性：由于关注点分离和代码重用，AOP使得系统更加易于维护。

在.NET环境中，也有一些常用的AOP框架，如：

AspectCore：AspectCore是一个轻量级的AOP框架，支持多种IOC容器，并且支持接口和类的拦截。它已经在多个项目中得到了应用，并且具有良好的性能和灵活性。
PostSharp：PostSharp是一个功能强大的AOP框架，它支持在编译时注入切面，从而避免了运行时的性能开销。PostSharp提供了丰富的功能和选项，使得开发者可以轻松地实现各种横切关注点。
Castle DynamicProxy：虽然Castle DynamicProxy本身不是一个专门的AOP框架，但它是一个强大的动态代理库，可以用来实现AOP的一些功能。通过结合Castle DynamicProxy和其他工具或框架，开发者可以实现自己的AOP解决方案。