Emit实现简单的Aop

最近在研究Emit，发现其实Emit很简单，但是IL很难，还好以前学习过汇编研究了很久才把指令搞清楚.

首先就来看看需要实现一个简单的Aop需要的类:

首先是拦截器,这里仿照Wcf的IParameterInspector定义了一个简单的接口，不支持ref和out参数。

 /// <summary>
    /// 拦截器接口
    /// </summary>
    public interface IInterceptor
    {
        /// <summary>
        /// 方法调用前
        /// </summary>
        /// <param name="operationName">方法名</param>
        /// <param name="inputs">参数</param>
        /// <returns>状态对象，用于调用后传入</returns>
        object BeforeCall(string operationName, object[] inputs);

        /// <summary>
        /// 方法调用后
        /// </summary>
        /// <param name="operationName">方法名</param>
        /// <param name="returnValue">结果</param>
        /// <param name="correlationState">状态对象</param>
        void AfterCall(string operationName, object returnValue, object correlationState);
    }

创建一个简单的实现来测试

  public class StandardInterceptor : IInterceptor
    {
       

        public object BeforeCall(string operationName, object[] inputs)
        {
            Console.WriteLine("Before call :{0}", operationName);
            return null;
        }

        public void AfterCall(string operationName, object returnValue, object correlationState)
        {
            Console.WriteLine("After call :{0} resule: {1}", operationName, returnValue??"Null");
        }
    }

简单工厂模式定义拦截器工厂

 public class DefaultInterceptorFactory
    {
        public static IInterceptor Create(Type type)
        {
            return new StandardInterceptor();
        }
    }

接下来定义一个测试类型

public class Animal
    {
        public virtual string Speak(string msg)
        {
            Console.WriteLine("Animal.Speak:{0}", msg);
            return msg;
        }

        public virtual void Speak()
        {
            Console.WriteLine("Animal.Speak");
        }
    }

Aop采用继承的方式，通过Emit构造子类，为了方便先用程序将子类编写好方便对比IL调试

 public class AnimalAop : Animal
    {

        private readonly IInterceptor _inspector;

        public AnimalAop()
        {
            _inspector = DefaultInterceptorFactory.Create(typeof(Animal));
        }

        public override void Speak()
        {
            object correlationState = _inspector.BeforeCall("Speak", null);
            base.Speak();
            object result = null;
            _inspector.AfterCall("Speak", result, correlationState);
        }

        public override string Speak(string msg)
        {
            object correlationState = _inspector.BeforeCall("Speak", new object[] { msg });
            var result = base.Speak(msg);
            _inspector.AfterCall("Speak", result, correlationState);
            return result;
        }
    }

好了，准备工作完成了，接下来就是如何来用Emit生成这个代理对象

依然是简单工厂DefaultProxyBuilder

public static T CreateProxy<T>()
        {
            Type classType = typeof(T);

            string name = classType.Namespace + ".Aop";
            string fileName = name + ".dll";


            

            AssemblyName assemblyName = new AssemblyName(name);
            var assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName,
                                                                                AssemblyBuilderAccess.RunAndSave);
            var moduleBuilder = assemblyBuilder.DefineDynamicModule(name, fileName);
            var aopType = BulidType(classType, moduleBuilder);

            assemblyBuilder.Save(fileName);
            return (T)Activator.CreateInstance(aopType);
        }

构建类包含了

1 构建类型

//定义类型
            var typeBuilder = moduleBuilder.DefineType(className,
                                                       TypeAttributes.Public | TypeAttributes.Sealed | TypeAttributes.Class,
                                                       classType);

2 构建拦截器字段_inspector

 var inspectorFieldBuilder = typeBuilder.DefineField("_inspector", typeof (IInterceptor),
                                                                FieldAttributes.Private | FieldAttributes.InitOnly);

3 构建构造函数 初始化inspector

var ctorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.HasThis,
                                                                Type.EmptyTypes);
                var il = ctorBuilder.GetILGenerator();

                il.Emit(OpCodes.Ldarg_0);
                il.Emit(OpCodes.Call, classType.GetConstructor(Type.EmptyTypes));//调用base的默认ctor
                il.Emit(OpCodes.Ldarg_0);
                //将typeof(classType)压入计算堆
                il.Emit(OpCodes.Ldtoken, classType);
                il.Emit(OpCodes.Call, typeof (Type).GetMethod("GetTypeFromHandle", new[] {typeof (RuntimeTypeHandle)}));
                //调用DefaultInterceptorFactory.Create(type)
                il.Emit(OpCodes.Call, typeof (DefaultInterceptorFactory).GetMethod("Create", new[] {typeof (Type)}));
                //将结果保存到字段_inspector
                il.Emit(OpCodes.Stfld, inspectorFieldBuilder);
                il.Emit(OpCodes.Ret);

 
4 构建方法 使用拦截器_inspector
首先得到父类的methodInfo 获取必要的信息

  var parameterInfos = methodInfo.GetParameters();
                var parameterTypes = parameterInfos.Select(p => p.ParameterType).ToArray();
                var parameterLength = parameterTypes.Length;
                var hasResult = methodInfo.ReturnType != VoidType;

                var methodBuilder = typeBuilder.DefineMethod(methodInfo.Name,
                                                             MethodAttributes.Public | MethodAttributes.Final |
                                                             MethodAttributes.Virtual
                                                             , methodInfo.ReturnType
                                                             , parameterTypes);

定义局部变量 这个顺序很重要 下面的操作要使用到

var il = methodBuilder.GetILGenerator();

                //局部变量
                il.DeclareLocal(typeof (object)); //correlationState
                il.DeclareLocal(typeof (object)); //result
                il.DeclareLocal(typeof (object[])); //parameters

首先是调用BeforeCall

 //BeforeCall(string operationName, object[] inputs);
                il.Emit(OpCodes.Ldarg_0);

                il.Emit(OpCodes.Ldfld, inspectorFieldBuilder);//获取字段_inspector
                il.Emit(OpCodes.Ldstr, methodInfo.Name);//参数operationName

                if (parameterLength == 0)//判断方法参数长度
                {
                    il.Emit(OpCodes.Ldnull);//null -> 参数 inputs
                }
                else
                {
                    //创建new object[parameterLength];
                    il.Emit(OpCodes.Ldc_I4, parameterLength);
                    il.Emit(OpCodes.Newarr, typeof(Object));
                    il.Emit(OpCodes.Stloc_2);//压入局部变量2 parameters

                    for (int i = 0, j = 1; i < parameterLength; i++, j++)
                    {
                        //object[i] = arg[j]
                        il.Emit(OpCodes.Ldloc_2);
                        il.Emit(OpCodes.Ldc_I4, 0);
                        il.Emit(OpCodes.Ldarg, j);
                        if (parameterTypes[i].IsValueType) il.Emit(OpCodes.Box, parameterTypes[i]);//对值类型装箱
                        il.Emit(OpCodes.Stelem_Ref);
                    }
                    il.Emit(OpCodes.Ldloc_2);//取出局部变量2 parameters-> 参数 inputs
                }

                il.Emit(OpCodes.Callvirt, typeof(IInterceptor).GetMethod("BeforeCall"));//调用BeforeCall
                il.Emit(OpCodes.Stloc_0);//建返回压入局部变量0 correlationState

接下来调用base的方法

 //Call methodInfo
                il.Emit(OpCodes.Ldarg_0);
                //获取参数表
                for (int i = 1, length = parameterLength + 1; i < length; i++)
                {
                    il.Emit(OpCodes.Ldarg_S, i);
                }
                il.Emit(OpCodes.Call, methodInfo);
                //将返回值压入 局部变量1result void就压入null
                if (!hasResult) il.Emit(OpCodes.Ldnull);
                else if (methodInfo.ReturnType.IsValueType) il.Emit(OpCodes.Box, methodInfo.ReturnType);//对值类型装箱
                il.Emit(OpCodes.Stloc_1);

下面调用AfterCall

  //AfterCall(string operationName, object returnValue, object correlationState);
                il.Emit(OpCodes.Ldarg_0);
                il.Emit(OpCodes.Ldfld, inspectorFieldBuilder);//获取字段_inspector
                il.Emit(OpCodes.Ldstr, methodInfo.Name);//参数 operationName
                il.Emit(OpCodes.Ldloc_1);//局部变量1 result -> 参数 returnValue
                il.Emit(OpCodes.Ldloc_0);// 局部变量0 correlationState -> 参数 correlationState
                il.Emit(OpCodes.Callvirt, typeof (IInterceptor).GetMethod("AfterCall"));

最后是返回

//result
                if (!hasResult)
                {
                    il.Emit(OpCodes.Ret);
                    return;
                }
                il.Emit(OpCodes.Ldloc_1);//非void取出局部变量1 result
                if (methodInfo.ReturnType.IsValueType) il.Emit(OpCodes.Unbox_Any, methodInfo.ReturnType);//对值类型拆箱
                il.Emit(OpCodes.Ret);

完成实现如下：

public static class DefaultProxyBuilder
    {
        private static readonly Type VoidType = Type.GetType("System.Void");

        public static T CreateProxy<T>()
        {
            Type classType = typeof(T);

            string name = classType.Namespace + ".Aop";
            string fileName = name + ".dll";


            var assemblyName = new AssemblyName(name);
            var assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName,
                                                                                AssemblyBuilderAccess.RunAndSave);
            var moduleBuilder = assemblyBuilder.DefineDynamicModule(name, fileName);
            var aopType = BulidType(classType, moduleBuilder);

            assemblyBuilder.Save(fileName);
            return (T)Activator.CreateInstance(aopType);
        }

        private static Type BulidType(Type classType, ModuleBuilder moduleBuilder)
        {
            string className = classType.Name + "_Proxy";

            //定义类型
            var typeBuilder = moduleBuilder.DefineType(className,
                                                       TypeAttributes.Public | TypeAttributes.Sealed | TypeAttributes.Class,
                                                       classType);
            //定义字段 _inspector
            var inspectorFieldBuilder = typeBuilder.DefineField("_inspector", typeof(IInterceptor),
                                                                FieldAttributes.Private | FieldAttributes.InitOnly);
            //构造函数
            BuildCtor(classType, inspectorFieldBuilder, typeBuilder);

            //构造方法
            BuildMethod(classType, inspectorFieldBuilder, typeBuilder);
            Type aopType = typeBuilder.CreateType();
            return aopType;
        }

        private static void BuildMethod(Type classType, FieldBuilder inspectorFieldBuilder, TypeBuilder typeBuilder)
        {
            var methodInfos = classType.GetMethods();
            foreach (var methodInfo in methodInfos)
            {
                if (!methodInfo.IsVirtual && !methodInfo.IsAbstract) continue;
                if (methodInfo.Name == "ToString") continue;
                if (methodInfo.Name == "GetHashCode") continue;
                if (methodInfo.Name == "Equals") continue;

                var parameterInfos = methodInfo.GetParameters();
                var parameterTypes = parameterInfos.Select(p => p.ParameterType).ToArray();
                var parameterLength = parameterTypes.Length;
                var hasResult = methodInfo.ReturnType != VoidType;

                var methodBuilder = typeBuilder.DefineMethod(methodInfo.Name,
                                                             MethodAttributes.Public | MethodAttributes.Final |
                                                             MethodAttributes.Virtual
                                                             , methodInfo.ReturnType
                                                             , parameterTypes);

                var il = methodBuilder.GetILGenerator();

                //局部变量
                il.DeclareLocal(typeof(object)); //correlationState
                il.DeclareLocal(typeof(object)); //result
                il.DeclareLocal(typeof(object[])); //parameters

                //BeforeCall(string operationName, object[] inputs);
                il.Emit(OpCodes.Ldarg_0);

                il.Emit(OpCodes.Ldfld, inspectorFieldBuilder);//获取字段_inspector
                il.Emit(OpCodes.Ldstr, methodInfo.Name);//参数operationName

                if (parameterLength == 0)//判断方法参数长度
                {
                    il.Emit(OpCodes.Ldnull);//null -> 参数 inputs
                }
                else
                {
                    //创建new object[parameterLength];
                    il.Emit(OpCodes.Ldc_I4, parameterLength);
                    il.Emit(OpCodes.Newarr, typeof(Object));
                    il.Emit(OpCodes.Stloc_2);//压入局部变量2 parameters

                    for (int i = 0, j = 1; i < parameterLength; i++, j++)
                    {
                        //object[i] = arg[j]
                        il.Emit(OpCodes.Ldloc_2);
                        il.Emit(OpCodes.Ldc_I4, 0);
                        il.Emit(OpCodes.Ldarg, j);
                        if (parameterTypes[i].IsValueType) il.Emit(OpCodes.Box, parameterTypes[i]);//对值类型装箱
                        il.Emit(OpCodes.Stelem_Ref);
                    }
                    il.Emit(OpCodes.Ldloc_2);//取出局部变量2 parameters-> 参数 inputs
                }

                il.Emit(OpCodes.Callvirt, typeof(IInterceptor).GetMethod("BeforeCall"));//调用BeforeCall
                il.Emit(OpCodes.Stloc_0);//建返回压入局部变量0 correlationState

                //Call methodInfo
                il.Emit(OpCodes.Ldarg_0);
                //获取参数表
                for (int i = 1, length = parameterLength + 1; i < length; i++)
                {
                    il.Emit(OpCodes.Ldarg_S, i);
                }
                il.Emit(OpCodes.Call, methodInfo);
                //将返回值压入 局部变量1result void就压入null
                if (!hasResult) il.Emit(OpCodes.Ldnull);
                else if (methodInfo.ReturnType.IsValueType) il.Emit(OpCodes.Box, methodInfo.ReturnType);//对值类型装箱
                il.Emit(OpCodes.Stloc_1);

                //AfterCall(string operationName, object returnValue, object correlationState);
                il.Emit(OpCodes.Ldarg_0);
                il.Emit(OpCodes.Ldfld, inspectorFieldBuilder);//获取字段_inspector
                il.Emit(OpCodes.Ldstr, methodInfo.Name);//参数 operationName
                il.Emit(OpCodes.Ldloc_1);//局部变量1 result
                il.Emit(OpCodes.Ldloc_0);// 局部变量0 correlationState
                il.Emit(OpCodes.Callvirt, typeof(IInterceptor).GetMethod("AfterCall"));

                //result
                if (!hasResult)
                {
                    il.Emit(OpCodes.Ret);
                    return;
                }
                il.Emit(OpCodes.Ldloc_1);//非void取出局部变量1 result
                if (methodInfo.ReturnType.IsValueType) il.Emit(OpCodes.Unbox_Any, methodInfo.ReturnType);//对值类型拆箱
                il.Emit(OpCodes.Ret);
            }
        }

        private static void BuildCtor(Type classType, FieldBuilder inspectorFieldBuilder, TypeBuilder typeBuilder)
        {
            {
                var ctorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.HasThis,
                                                                Type.EmptyTypes);
                var il = ctorBuilder.GetILGenerator();

                il.Emit(OpCodes.Ldarg_0);
                il.Emit(OpCodes.Call, classType.GetConstructor(Type.EmptyTypes));//调用base的默认ctor
                il.Emit(OpCodes.Ldarg_0);
                //将typeof(classType)压入计算堆
                il.Emit(OpCodes.Ldtoken, classType);
                il.Emit(OpCodes.Call, typeof(Type).GetMethod("GetTypeFromHandle", new[] { typeof(RuntimeTypeHandle) }));
                //调用DefaultInterceptorFactory.Create(type)
                il.Emit(OpCodes.Call, typeof(DefaultInterceptorFactory).GetMethod("Create", new[] { typeof(Type) }));
                //将结果保存到字段_inspector
                il.Emit(OpCodes.Stfld, inspectorFieldBuilder);
                il.Emit(OpCodes.Ret);
            }
        }
    }

测试一下：

static void Main(string[] args)
        {
            Animal animal = DefaultProxyBuilder.CreateProxy<Animal>();
            animal.Speak();
            Console.WriteLine();
            animal.Speak("Hello");
        }

打印结果：

Before call :Speak

Animal.Speak

After call :Speak resule: Null

Before call :Speak

Animal.Speak:Hello

After call :Speak resule: Hello