Aspect#中的代理对象

代理对象是AOP动态截入的关键部分. 下面来分析一下代理对象是如何定义的.

1. CreateProxyType

internal static Type CreateProxyType(Type[] interfaces, IMixin[] mixins)  {
     //...
     AssemblyName assemblyName = new AssemblyName();
     assemblyName.Name = "DynamicAssemblyProxyGen";

     AssemblyBuilder assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(
                assemblyName, AssemblyBuilderAccess.Run);
     // 以指定名称和访问模式定义动态程序集, 这里以运行模式建立程序集.
   
     ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule( assemblyName.Name, true );
     // 在动态程序集中定义动态模块, 第二个参数发出符号信息.

     TypeBuilder typeBuilder = moduleBuilder.DefineType( "ProxyType",
             TypeAttributes.Public|TypeAttributes.Class, null, MergeTypes(interfaces, mixins) );
     // 定义一个类类型, 此类为public, 且实现所有的interfaces和mixins接口,
     // MergeTypes用于将interfaces和mixins合并为一个Type[].

     FieldBuilder handlerField = GenerateField( typeBuilder, handlerFieldName, typeof(IInvocationHandler) );
     // 产生一个IInvocationHandler字段. 等同于 public IInvocationHandler handler;

     FieldBuilder mixinHandlerField = GenerateField( typeBuilder, mixinHandlerFieldName,
          typeof(IMixinInvocationHandler) );
      // 产生一个IMixinInvocation字段. 等同于 public IMixinInvocationHandler mixinHandler;
   
      FieldBuilder mixinsField = GenerateField( typeBuilder, "mixins", typeof(IMixin[]) );
       // 产生一个IMixin[]字段, 等同于 public IMixin[] mixins;

       ConstructorBuilder constr = GenerateConstructor( typeBuilder, handlerField, mixinsField, mixinHandlerField );
       // 产生一个构造方法.

       GenerateInterfaceImplementation( typeBuilder, interfaces, handlerField );
       // 产生接口的实现部分.

       GenerateMixinImplementation( typeBuilder, mixins, mixinHandlerField, mixinsField);
       // 产生混合器接口的实现部分.
}

2. GenerateConstructor

private static ConstructorBuilder GenerateConstructor( TypeBuilder typeBuilder,
 FieldBuilder handlerField, FieldBuilder mixinsField, FieldBuilder mixinHandlerField ) {
   ConstructorBuilder consBuilder = typeBuilder.DefineConstructor(
         MethodAttributes.Public,
         CallingConventions.Standard,
         new Type[] { typeof(IInvocationHandler), typeof(IMixinInvocationHandler), typeof(IMixin[]) } );
   
     // 定义一个构造方法, 指定方法修饰为Public, 调用约定为Standard. 
     // 等同于 public ProxyType( IInvocationHandler handler, IMixinInvocationHandler mixinHandler, IMixin[] mixins );

      ILGenerator ilGenerator = consBuilder.GetILGenerator();
      // 取得IL产生器. 用于生成IL代码.

      ilGenerator.Emit(OpCodes.Ldarg_0);
      ilGenerator.Emit(OpCodes.Call, typeof(Object).GetConstructor(new Type[0]));
      // 调用Object类型的默认构造函数, 等同于 public ProxyType(...) : base()
  
      // handler
      ilGenerator.Emit(OpCodes.Ldarg_0);
      ilGenerator.Emit(OpCodes.Ldarg_1);
      ilGenerator.Emit(OpCodes.Stfld, handlerField);
      // 对handlerField字段进行赋值, 等同于 this.handler = handler;
   
       // mixinHandler
       ilGenerator.Emit(OpCodes.Ldarg_0);
       ilGenerator.Emit(OpCodes.Ldarg_2);
       ilGenerator.Emit(OpCodes.Stfld, mixinHandlerField);
       // 对mixinHandlerField字段进行赋值, 等同于 this.mixinHandler = mixinHandler;

       // mixins
       ilGenerator.Emit(OpCodes.Ldarg_0);
       ilGenerator.Emit(OpCodes.Ldarg_3);
       ilGenerator.Emit(OpCodes.Stfld, mixinsField);
       // 对mixinsField字段进行赋值, 等同于 this.mixins = mixins

       ilGenerator.Emit(OpCodes.Ret);

       return consBuilder;
}

代理对象的构造方法类似如下:

public Class ProxyType : 对象接口, 混合器接口 {
     private IInvocationHandler handler;
     private IMixinvocationHandler mixinHandler;
     private IMixin[] mixins;

     public public ProxyType( IInvocationHandler handler,
          IMixinInvocationHandler mixinHandler, IMixin[] mixins );   {
           this.handler = handler;
          this.mixinHandler = mixinHandler;
          this.mixins = mixins;
      }

      // ...  
}

3. 产生接口的实现部分

static void GenerateInterfaceImplementation( TypeBuilder typeBuilder,
       Type[] interfaces, FieldBuilder handlerField ) {
       foreach(Type inter in interfaces) {
          GenerateInterfaceImplementation( typeBuilder, inter, handlerField, null, -1 );
      }
      // 遍历所有接口.
}

private static void GenerateMixinImplementation( TypeBuilder typeBuilder,
        IMixin[] mixins, FieldBuilder mixinHandlerField, FieldBuilder mixinsField) {
       if (mixins == null) return;

       for(int i = 0; i < mixins.Length; i++) {
           Type[] interfaces = mixins[i].GetType().GetInterfaces();

           foreach(Type inter in interfaces)  {
              GenerateInterfaceImplementation( typeBuilder, inter, mixinHandlerField, mixinsField, i );
          }
     }
      // 遍历所有的混合器接口
}

static void GenerateInterfaceImplementation( TypeBuilder typeBuilder,
       Type inter, FieldBuilder handlerField, FieldBuilder mixinsField, int mixinPosition) {
       // ...

       Type[] baseInterfaces = inter.FindInterfaces( new TypeFilter( NoFilterImpl ), inter );
       GenerateInterfaceImplementation( typeBuilder, baseInterfaces, handlerField);
        // 这是一个递归过程, 用于遍历所有的接口.

        PropertyInfo[] properties = inter.GetProperties();
        PropertyBuilder[] propertiesBuilder = new PropertyBuilder[properties.Length];
        for(int i=0; i < properties.Length; i++)  {
            GeneratePropertyImplementation( typeBuilder, properties[i], ref propertiesBuilder[i] );
        }
        // 产生属性的实现.

        MethodInfo[] methods = inter.GetMethods();
        foreach(MethodInfo method in methods) {
             GenerateMethodImplementation( typeBuilder, method, propertiesBuilder, inter,
                   handlerField, mixinsField, mixinPosition );
       }
       // 产生方法的实现.
}

// 属性的实现.
private static void GeneratePropertyImplementation( TypeBuilder typeBuilder,
      PropertyInfo property, ref PropertyBuilder propertyBuilder ) {
       propertyBuilder = typeBuilder.DefineProperty( 
       property.Name, property.Attributes, property.PropertyType, null);
      // 通过调用DefindProperty方法来产生属性的实现部分.
}

// 方法的实现.
private static void GenerateMethodImplementation(  TypeBuilder typeBuilder,
      MethodInfo method, PropertyBuilder[] properties,   Type inter,
      FieldBuilder handlerField, FieldBuilder mixinsField, int mixinPosition )  {
        ParameterInfo[] parameterInfo = method.GetParameters();
        // 取得参数信息.

      System.Type[] parameters = new System.Type[parameterInfo.Length];
      for (int i=0; i            parameters[i] = parameterInfo[i].ParameterType;
      }
      // 取得参数的类型.

       MethodAttributes atts = MethodAttributes.Public|MethodAttributes.Virtual;
       if ( method.Name.StartsWith("set_") || method.Name.StartsWith("get_") ) {
          atts = MethodAttributes.Public|MethodAttributes.SpecialName|MethodAttributes.Virtual;
      }
      // 指定方法的修饰.

      MethodBuilder methodBuilder =  typeBuilder.DefineMethod( method.Name, atts,
          CallingConventions.Standard, method.ReturnType, parameters );
       // 定义方法.

       if ( method.Name.StartsWith("set_") || method.Name.StartsWith("get_") ) {
           foreach( PropertyBuilder property in properties )  {
                if (property == null)  {
                    break;
               }

                if (!property.Name.Equals( method.Name.Substring(4) )) {
                     continue;
                }

                if ( methodBuilder.Name.StartsWith("set_") )  {
                     property.SetSetMethod( methodBuilder );
                     break;
                }
                else  {
                     property.SetGetMethod( methodBuilder );
                     break;
                }
           }
           // 如果方法以set_或get_开头, 则遍历所有的属性, 如果名称相同则设置属性的set/get方法.
     }

     WriteILForMethod( methodBuilder, parameters, handlerField, mixinsField, mixinPosition );
     // 方法的IL代码.
}

方法实现的具体代码, 这个可是关键哦, 拦截和混合应该在这里进行处理.

private static void WriteILForMethod( MethodBuilder builder, System.Type[] parameters,
       FieldBuilder handlerField, FieldBuilder mixinsField, int mixinPosition )   {
         int arrayPositionInStack = 1;

         ILGenerator ilGenerator = builder.GetILGenerator();

         ilGenerator.DeclareLocal( typeof( MethodBase ) );
         // 定义一个MothodBase类型的局部变量.

         if (builder.ReturnType != typeof(void))
         {
                  ilGenerator.DeclareLocal(builder.ReturnType);
                  arrayPositionInStack = 2;
         }
         // 如果有返回值, 则定义一个局部变量用来保存返回值.

         ilGenerator.DeclareLocal( typeof(object[]) );
         // 定义一个object[]类型的局部变更.

         ilGenerator.Emit(OpCodes.Call, typeof(MethodBase).GetMethod("GetCurrentMethod") );
         // 调用GetCurrentMethod方法.

         ilGenerator.Emit(OpCodes.Stloc_0);
         ilGenerator.Emit(OpCodes.Ldarg_0);
         ilGenerator.Emit(OpCodes.Ldfld, handlerField );
           
         // this 
         ilGenerator.Emit(OpCodes.Ldarg_0);

         // method base
         ilGenerator.Emit(OpCodes.Ldloc_0);
   
         // mixin
         if ( mixinPosition > -1 )  {
                 ilGenerator.Emit(OpCodes.Ldarg_0);
                 ilGenerator.Emit(OpCodes.Ldfld, mixinsField );
                 ilGenerator.Emit(OpCodes.Ldc_I4, mixinPosition);
                 ilGenerator.Emit(OpCodes.Ldelem_Ref);
         }

         // arguments
         ilGenerator.Emit(OpCodes.Ldc_I4, parameters.Length);
         ilGenerator.Emit(OpCodes.Newarr, typeof(object) );

         if (parameters.Length != 0) {
                 ilGenerator.Emit(OpCodes.Stloc, arrayPositionInStack);
                 ilGenerator.Emit(OpCodes.Ldloc, arrayPositionInStack);
         }

         for (int c=0; c                 ilGenerator.Emit(OpCodes.Ldc_I4, c);
                ilGenerator.Emit(OpCodes.Ldarg, c+1);

                if (parameters[c].IsValueType) {
                     ilGenerator.Emit(OpCodes.Box, parameters[c].UnderlyingSystemType);
                }

                 ilGenerator.Emit(OpCodes.Stelem_Ref);
                 ilGenerator.Emit(OpCodes.Ldloc, arrayPositionInStack);
         }

         switch (handlerField.Name)  {
                  case mixinHandlerFieldName:  {
                           ilGenerator.Emit(OpCodes.Callvirt, typeof(IMixinInvocationHandler).GetMethod("Invoke") );
                           break;
                  }
                  default: {
                          ilGenerator.Emit(OpCodes.Callvirt, typeof(IInvocationHandler).GetMethod("Invoke") );
                          break;
                  }
         }
         // 根据字段的名称进行处理. OpCodes.Callvirtr指定为后期绑定.
         // 如果字段属于混合器接口, 则执行IMixinInvocationHandler.Invoke,
         // 否则调用IInvocationHandler.Invoke.

         if (builder.ReturnType != typeof(void))  {
               if (!builder.ReturnType.IsValueType)  {
                    ilGenerator.Emit(OpCodes.Castclass, builder.ReturnType);
               }
               else {
                   ilGenerator.Emit(OpCodes.Unbox, builder.ReturnType);
                   ilGenerator.Emit(ConvertTypeToOpCode(builder.ReturnType));
                }

                ilGenerator.Emit(OpCodes.Stloc, 1);

                Label label = ilGenerator.DefineLabel();
                ilGenerator.Emit(OpCodes.Br_S, label);
                ilGenerator.MarkLabel(label);
                ilGenerator.Emit(OpCodes.Ldloc, 1);
         }
         else  {
                ilGenerator.Emit(OpCodes.Pop);
         }

         ilGenerator.Emit(OpCodes.Ret);
}

// 对IL不是很熟, 一些细节还没弄清楚. 望熟悉IL的朋友予于指正和补充.