Interposer - 实现AOP的又一个方法...

Zezeze...怎么每次新的技术,好的思想都是外国人发现/发明的呢??难道中国人就想不到么?还是别的什么了........

在上一篇文章中,我介绍了使用DynamicProxy实现ExceptionLog的方法..其核心思想就是通过Reflection得到实际对象的接口类(其实得到的是接口的函数描述),从得到的接口类动态派生一个类,这个类的所有函数(从接口继承下来的)都被Hook了.此对象的所有函数调用都转向Invoke....

今天我来介绍一个比较简单的方法...其实这个东东在Steeven的帖子利用Attribute给C#实现AOP? 的评论就提到过的:P
我们一步一步的看这个东东的代码:P
   public class Interposer      :
      System.Runtime.Remoting.Proxies.RealProxy,
      System.Runtime.Remoting.IRemotingTypeInfo

好,上面的是类的声明,可以看出来,这个类是继承自RealProxy..呵呵,有没有想到什么?  对使用透明代理..是的....那实际的类得从MarshalByRefObject 继承么??还有,那个IRemotingTypeInfo是干什么的?? 呵呵,不用急,..我们再看后面的...

      private Interposer( object target )
         :
         base( typeof( IInterposed ) )
      {
         m_target = target;
      }
可以看出来,传给基类的参数是一个IInterposed的类型..
   public interface IInterposed
   {
      object Target
      {
         get;
      }
   }
这是一个接口,没有任何方法,也没有实现任何属性.Zeze,又是问号??.不急,我们慢慢看后面的..

      public override System.Runtime.Remoting.Messaging.IMessage Invoke( System.Runtime.Remoting.Messaging.IMessage message )
      {
         System.Runtime.Remoting.Messaging.IMethodCallMessage methodMessage =
            new System.Runtime.Remoting.Messaging.MethodCallMessageWrapper( (System.Runtime.Remoting.Messaging.IMethodCallMessage) message );

         System.Reflection.MethodBase method = methodMessage.MethodBase;

         object returnValue = null;

         // Handle IInterposed methods/properties here.  Right now, there is
         // only one property, so don't do any extensive checking to determine
         // the method being invoked.
         if ( method.DeclaringType == typeof( IInterposed ) )
         {
            returnValue = m_target;
         }
         else
         {
    try {
     returnValue = method.Invoke( m_target, methodMessage.Args );
    }
    catch (System.Exception ex) {
    returnValue = null;
    }
         }

         System.Runtime.Remoting.Messaging.ReturnMessage returnMessage =
            new System.Runtime.Remoting.Messaging.ReturnMessage( returnValue, methodMessage.Args, methodMessage.ArgCount, methodMessage.LogicalCallContext, methodMessage );

         return returnMessage;
      }
既然是通过透明代理实现的,那就得有Invoke函数,对,上面就是这个函数.
通过上面的代码,我们可以发现,实际上是调用对象m_target的函数,m_target就是构造函数中传进去的对象...
这就是生成透明代理的地方了:
      public static object Wrap( object target )
      {
         Interposer interposer = new Interposer( target );
         return interposer.GetTransparentProxy();
      }

呵呵,到这里应该大部分都明白了,通过构造函数把实际的对象(你想操作的)传进去,得到透明代理,再通过透明代理进行调用..

咦,等等,传给RealProxy类的参数是IInterposed啊,不是我们实际的对象啊????

嗯,这就是"the key".因为我们这个类继承自IRemotingTypeInfo,实现这个接口后,我们可以把这个类型转化为任何类型(理论上,而且只是在编译时可以通过编译.如果在程序运行时把这个转成别的完全不一样的类,那会在调用函数时产生异常的).那么在调用强行转换后的类的函数时,通过透明代理,会把此对象的所有的函数调用信息(就算他自己没有这个函数,也会转发的,不会产生异常,如果没用透明代理,那就会像前面说的那样,产生异常)转发给Invoke函数,在这里,我们就调用实际的函数了.酱紫,我们就完成了函数调用的乾坤大挪移了:P...

好了,核心部分说完了.再看看Client调用方式:
   public interface ISampleTarget
   {
      void DoSomething();
      void DoException();
   }

   public interface INotImplemented
   {
      void Nothing();
   }

   public class SampleTarget : ISampleTarget,INotImplemented
   {
      public void DoSomething()
      {
         System.Console.WriteLine( "Doing Something." );
      }

      public void DoException( out int value )
      {
              throw new System.Exception("tt"); //测试异常
     }
   }
同样的,我们得从接口继承类...
         SampleTarget realTarget = new SampleTarget();

         ISampleTarget interposedTarget = (ISampleTarget) Interposer.Interposer.Wrap( realTarget );

         interposedTarget.DoSomething();

         object target = ( (Interposer.IInterposed) interposedTarget ).Target;

         System.Console.WriteLine( "Interposed target type: {0}", target.GetType() );

         INotImplemented target2 = (INotImplemented) interposedTarget;

         try
         {
            target2.Nothing();
         }
         catch ( System.Exception e )
         {
            System.Console.WriteLine( "Expected exception: {0}", e );
         }

从代码中红色的部分可以看出来,把Interposer对象转换成ISampleTarget(还记得我前面说得吗?? :) ),再调用函数....
呵呵,运行一下效果就完全出来了...

源文件从这个地方下载: Interposer

上述这个方法很轻便,比使用Emit的方式要简单的多...但是和DynamicProxy一样,还是不能Interrupt 构造函数...
看来我们可能还得等JGTM的大作了:P