.netCore用DispatchProxy实现动态代理

在 .NET Core 中，你可以使用 DispatchProxy 类来实现动态代理。DispatchProxy 允许你在运行时创建一个代理对象，该代理对象可以拦截对其所代理的对象的方法调用，并在方法调用前后执行自定义的逻辑。这在 AOP（面向切面编程）和其他一些场景中非常有用。

以下是一个简单的示例，演示如何使用 DispatchProxy 实现动态代理：

首先，你需要创建一个实现了 DispatchProxy 抽象类的代理类，并重写其中的 Invoke 方法。在 Invoke 方法中，你可以添加自己的逻辑，比如在方法调用前后执行一些操作。

using System;
using System.Reflection;
using System.Threading.Tasks;
using System.Runtime.CompilerServices;
using System.Runtime.Remoting.Messaging;

public class MyProxy<T> : DispatchProxy
{
    private T _decorated;

    protected override object Invoke(MethodInfo targetMethod, object[] args)
    {
        Console.WriteLine($"Before invoking method {targetMethod.Name}");
        
        // 在调用目标方法之前、之后，可以添加自己的逻辑
        var result = targetMethod.Invoke(_decorated, args);
        
        Console.WriteLine($"After invoking method {targetMethod.Name}");
        
        return result;
    }

    public static T Create(T decorated)
    {
        object proxy = Create<T, MyProxy<T>>();
        ((MyProxy<T>)proxy)._decorated = decorated;
        return (T)proxy;
    }
}

接下来，你可以创建一个接口或类，然后实例化代理对象并使用它：

public interface ICalculator
{
    int Add(int a, int b);
    int Subtract(int a, int b);
}

public class Calculator : ICalculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }

    public int Subtract(int a, int b)
    {
        return a - b;
    }
}

class Program
{
    static void Main(string[] args)
    {
        ICalculator calculator = new Calculator();

        // 创建代理对象
        ICalculator proxy = MyProxy<ICalculator>.Create(calculator);

        int result = proxy.Add(5, 3);
        Console.WriteLine($"Result: {result}");

        result = proxy.Subtract(10, 4);
        Console.WriteLine($"Result: {result}");
    }
}

在上面的示例中，MyProxy 类是一个泛型类，它接受一个类型参数 T，代表你要代理的接口或类。在 Invoke 方法中，你可以添加你需要的逻辑，例如在方法调用前后打印日志。然后，通过调用 MyProxy.Create 方法，你可以创建一个代理对象，该对象实现了你指定的接口或类，并且会拦截方法调用并执行你的逻辑。

需要注意的是，DispatchProxy 只支持接口的代理。如果你要代理的是一个类而不是接口，你可能需要考虑其他的代理库，如 Castle DynamicProxy 或 LinFu。

当你使用动态代理时，你可以创建一个中间对象（代理对象），该对象可以拦截对另一个对象（目标对象）的方法调用，并在方法调用前后执行自定义的逻辑。这种技术通常用于实现横切关注点，例如日志记录、性能监测、事务管理等，而无需修改目标对象的代码。

在 .NET Core 中，DispatchProxy 是一个抽象类，允许你创建动态代理对象。它的作用是生成一个代理类，该代理类实现了一个接口，并在接口的方法调用时执行自定义的操作。以下是我上面提供的动态代理示例的详细解释：

1. 创建代理类 MyProxy：

   • 这个类是一个泛型类，它接受一个类型参数 T，代表你要代理的接口或类。
   • 该类继承自 DispatchProxy，这意味着它是一个动态代理类。
   • 在 MyProxy 类中，你重写了 Invoke 方法。Invoke 方法是 DispatchProxy 提供的一个虚拟方法，当代理对象调用其实现的接口方法时，Invoke 方法会被调用。
   • 在 Invoke 方法中，你可以添加自己的逻辑。在示例中，我简单地在方法调用前后打印了一条日志。

2. 创建目标接口和类：

   • 在示例中，我创建了一个简单的接口 ICalculator，以及一个实现了该接口的类 Calculator。这个类有两个方法：Add 和 Subtract。

3. 创建代理对象：

   • 在 Main 方法中，首先实例化了一个 Calculator 类的对象，并将其赋给 calculator 变量。
   • 然后，通过调用 MyProxy.Create(calculator) 创建了一个代理对象，该代理对象实现了 ICalculator 接口，并包装了 calculator 对象。

4. 使用代理对象：

   • 接下来，你可以使用代理对象 proxy 来调用接口方法，例如 proxy.Add(5, 3) 和 proxy.Subtract(10, 4)。
   • 由于代理对象是通过 MyProxy.Create 创建的，它会拦截这些方法调用，并在方法调用前后执行 Invoke 方法中定义的逻辑，这里是打印日志。

总之，DispatchProxy 的作用是允许你在运行时创建一个代理对象，该对象可以拦截方法调用并执行自定义的逻辑。这可以用于实现各种横切关注点，而不需要修改目标对象的代码，从而使代码更加可维护和可扩展。在示例中，我们使用 DispatchProxy 创建了一个简单的日志记录代理，但你可以根据需要添加其他功能。