AOP实现原理浅析（aop原理通俗易懂）

在C#中实现一个简单的动态代理框架，可以通过反射和System.Reflection.Emit命名空间动态生成代理类。以下是一个分步指南和示例代码：

核心实现思路

1. 拦截器接口：定义拦截逻辑的接口
2. 动态类型生成：使用AssemblyBuilder和TypeBuilder创建代理类型
3. 方法重写：覆盖基类或接口方法，插入拦截逻辑
4. 实例创建：通过反射实例化代理对象

具体实现代码

csharpCopy Codeusing System;
using System.Reflection;
using System.Reflection.Emit;

// 1. 定义拦截器接口
public interface IInterceptor
{
    object Intercept(MethodInfo method, object[] args, Func<object> proceed);
}

// 2. 代理生成器
public static class ProxyGenerator
{
    private static readonly AssemblyName AssemblyName = new AssemblyName("DynamicProxyAssembly");
    private static readonly AssemblyBuilder AssemblyBuilder =
        AssemblyBuilder.DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess.Run);
    private static readonly ModuleBuilder ModuleBuilder =
        AssemblyBuilder.DefineDynamicModule("DynamicProxyModule");

    public static T CreateClassProxy(T target, IInterceptor interceptor) where T : class
    {
        var type = BuildProxyType(typeof(T));
        return (T)Activator.CreateInstance(type, target, interceptor);
    }

    private static Type BuildProxyType(Type targetType)
    {
        TypeBuilder typeBuilder = ModuleBuilder.DefineType(
            $"{targetType.Name}Proxy",
            TypeAttributes.Public | TypeAttributes.Class,
            targetType);

        // 添加字段存储目标对象和拦截器
        FieldBuilder targetField = typeBuilder.DefineField(
            "_target", targetType, FieldAttributes.Private);
        FieldBuilder interceptorField = typeBuilder.DefineField(
            "_interceptor", typeof(IInterceptor), FieldAttributes.Private);

        // 定义构造函数
        DefineConstructor(typeBuilder, targetType, targetField, interceptorField);

        // 重写虚方法
        foreach (MethodInfo method in targetType.GetMethods(
            BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
        {
            if (method.IsVirtual)
            {
                OverrideMethod(typeBuilder, method, targetField, interceptorField);
            }
        }

        return typeBuilder.CreateType();
    }

    private static void DefineConstructor(TypeBuilder typeBuilder, Type targetType,
        FieldBuilder targetField, FieldBuilder interceptorField)
    {
        ConstructorBuilder ctor = typeBuilder.DefineConstructor(
            MethodAttributes.Public,
            CallingConventions.Standard,
            new[] { targetType, typeof(IInterceptor) });

        ILGenerator il = ctor.GetILGenerator();
        
        // 调用基类构造函数
        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Call, typeof(object).GetConstructor(Type.EmptyTypes));

        // 设置_target字段
        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Ldarg_1);
        il.Emit(OpCodes.Stfld, targetField);

        // 设置_interceptor字段
        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Ldarg_2);
        il.Emit(OpCodes.Stfld, interceptorField);

        il.Emit(OpCodes.Ret);
    }

    private static void OverrideMethod(TypeBuilder typeBuilder, MethodInfo method,
        FieldBuilder targetField, FieldBuilder interceptorField)
    {
        MethodBuilder methodBuilder = typeBuilder.DefineMethod(
            method.Name,
            MethodAttributes.Public | MethodAttributes.Virtual,
            method.ReturnType,
            method.GetParameters().Select(p => p.ParameterType).ToArray());

        typeBuilder.DefineMethodOverride(methodBuilder, method);

        ILGenerator il = methodBuilder.GetILGenerator();
        
        // 准备参数数组
        ParameterInfo[] parameters = method.GetParameters();
        LocalBuilder args = il.DeclareLocal(typeof(object[]));
        il.Emit(OpCodes.Ldc_I4, parameters.Length);
        il.Emit(OpCodes.Newarr, typeof(object));
        il.Emit(OpCodes.Stloc, args);

        for (int i = 0; i < parameters.Length; i++)
        {
            il.Emit(OpCodes.Ldloc, args);
            il.Emit(OpCodes.Ldc_I4, i);
            il.Emit(OpCodes.Ldarg, i + 1);
            if (parameters[i].ParameterType.IsValueType)
                il.Emit(OpCodes.Box, parameters[i].ParameterType);
            il.Emit(OpCodes.Stelem_Ref);
        }

        // 调用拦截器
        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Ldfld, interceptorField);
        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Ldfld, targetField);
        il.Emit(OpCodes.Callvirt, method);
        il.Emit(OpCodes.Ldloc, args);
        
        // 创建proceed委托
        LocalBuilder proceed = il.DeclareLocal(typeof(Func<object>));
        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Ldfld, targetField);
        il.Emit(OpCodes.Ldftn, method);
        il.Emit(OpCodes.Newobj, typeof(Func<object>).GetMethod("Invoke"));

        il.Emit(OpCodes.Callvirt, typeof(IInterceptor).GetMethod("Intercept"));
        
        if (method.ReturnType != typeof(void))
        {
            if (method.ReturnType.IsValueType)
                il.Emit(OpCodes.Unbox_Any, method.ReturnType);
        }
        else
        {
            il.Emit(OpCodes.Pop);
        }

        il.Emit(OpCodes.Ret);
    }
}

使用示例

csharpCopy Code// 目标类
public class MyService : IMyService
{
    public virtual string GetMessage(int id) => $"Message {id}";
}

// 拦截器实现
public class LogInterceptor : IInterceptor
{
    public object Intercept(MethodInfo method, object[] args, Func<object> proceed)
    {
        Console.WriteLine($"Before {method.Name}");
        object result = proceed();
        Console.WriteLine($"After {method.Name}");
        return result;
    }
}

// 使用代理
var service = new MyService();
var proxy = ProxyGenerator.CreateClassProxy(service, new LogInterceptor());
Console.WriteLine(proxy.GetMessage(123));

关键点说明

1. 类型生成：使用TypeBuilder创建继承自目标类型的新类型
2. 方法重写：通过DefineMethod和DefineMethodOverride实现方法覆盖
3. IL生成：使用ILGenerator编写MSIL代码实现方法拦截逻辑
4. 上下文传递：通过字段存储目标对象和拦截器实例
5. 委托封装：将原方法调用封装为Func<object>供拦截器调用

限制和扩展方向

• 当前实现仅支持虚方法
• 需要处理值类型装箱/拆箱
• 可扩展支持接口代理
• 需要添加异常处理逻辑
• 可增加属性/事件拦截

这个实现展示了动态代理的核心原理，实际生产环境建议使用成熟的库（如Castle DynamicProxy），但理解这些底层机制对掌握AOP实现原理非常有帮助。