动态织入的AOP实现

转载自：http://www.cnblogs.com/luminji/archive/2012/01/10/2318211.html

动态织入的AOP实现，有两种方法：

第一类，借助于Remoting命名空间下的几个类，通过获取当前上下文及反射的机制来实现，这需要被AOP的类需要继承自arshalByRefObject或者ContextBoundObject；

第二类，原理是基于动态代理的思想，即在运行时动态构造一个原有类的子类，这样就可以在子类的重载方法中插入额外代码。

这两类方法，都有显著的不足，前者直接要求我们继承固定类，后者呢，除非父类方法被定义为virtual，或者方法定义于某个接口，否则就不能被重载，这就是得“拦截”并不是可以对任意的方法进行的。

动态织入局限于CLR的限制，不能实现对任何方法进行AOP，如果要突破这个限制，只能采用静态织入的方法，静态织入采用。静态织入突破OO设计模式，可以拦截所有的方法甚至构造函数或属性访问器，因为它是直接修改IL。还有，因为它在运行前修改原有程序集，也就基本不存在运行时的性能损失问题了。它的不足，一方面是框架较复杂，实现较麻烦，依赖于对底层的IL指令集的操纵；

一：继承自ContextBoundObject的实现

帮助类：


  
  

   
   public 
   
   class 
   
   LogHandler : ICallHandler
  
  
  
  

   
   {
  
  
  
  

   
       
   
   /// <summary>
  
  
  
  

   
       
   
   /// 执行顺序
  
  
  
  

   
       
   
   /// </summary>
  
  
  
  

   
       
   
   public 
   
   int 
   
   Order { 
   
   get
   
   ; 
   
   set
   
   ; }
  
  
  
  

   
       
   
   public 
   
   IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext)
  
  
  
  

   
       
   
   {
  
  
  
  

   
           
   
   Console.WriteLine(
   
   "方法名: {0}"
   
   , input.MethodBase.Name);
  
  
  
  

   
           
   
   Console.WriteLine(
   
   "参数:"
   
   );
  
  
  
  

   
           
   
   for 
   
   (var i = 0; i < input.Arguments.Count; i++)
  
  
  
  

   
           
   
   {
  
  
  
  

   
               
   
   Console.WriteLine(
   
   "{0}: {1}"
   
   , input.Arguments.ParameterName(i), input.Arguments[i]);
  
  
  
  

   
           
   
   }
  
  
  
  

   
           
   
   Console.WriteLine(
   
   "方法执行前的处理"
   
   );
  
  
  
  

   
           
   
   var retvalue = getNext()(input, getNext);
  
  
  
  

   
           
   
   Console.WriteLine(
   
   "方法执行后的处理"
   
   );
  
  
  
  

   
           
   
   return 
   
   retvalue;
  
  
  
  

   
       
   
   }
  
  
  
  

   
   }
  
  
  
  

   
    
  
  
  
  

   
   public 
   
   class 
   
   LogHandlerAttribute : HandlerAttribute
  
  
  
  

   
   {
  
  
  
  

   
       
   
   public 
   
   override 
   
   ICallHandler CreateHandler(IUnityContainer container)
  
  
  
  

   
       
   
   {
  
  
  
  

   
           
   
   return 
   
   new 
   
   LogHandler();
  
  
  
  

   
       
   
   }
  
  
  
  

   
   }
  
  

调用方：

public interface ISample
{
    [LogHandler]
    void DoSomething();
    void DoSomethingNoAop();
}
 
class Sample1 : ISample
{
    public void DoSomething()
    {
        Console.WriteLine("Sample1 do something");
    }
 
    public void DoSomethingNoAop()
    {
        Console.WriteLine("Sample1 do something no aop");
    }
}
 
public class SampleClass
{
 
    [LogHandler]
    public virtual void SampleVirtual()
    {
        Console.WriteLine("Virtual method");
    }
 
    public void Sample()
    {
        Console.WriteLine("Sampe method");
    }
}
 
class Program {
 
    static void Main() {
        //针对接口
        var container1 = new UnityContainer()
            .AddNewExtension<Interception>()
            .RegisterType<ISample, Sample1>();
        container1
            .Configure<Interception>()
            .SetInterceptorFor<ISample>(new InterfaceInterceptor());
        container1
            .Configure<Interception>()
            .SetInterceptorFor<SampleClass>(new VirtualMethodInterceptor());
        var sample1 = container1.Resolve<ISample>();
        sample1.DoSomething();
        sample1.DoSomethingNoAop();
 
        //针对虚拟方法
        var sample2 = container1.Resolve<SampleClass>();
        sample2.SampleVirtual();
        sample2.Sample();
 
        Console.ReadKey();
    }
 
}

可以看到，第二种方法是用Unity实现的，关于Unity，这里多说两句：

Unity的AOP可以从3种标记的情况拦截：
TransparentProxyInterceptor：直接在类的方法上进行标记，但是这个类必须继承MarshalByRefObject；
VirtualMethod：直接在类的虚方法上进行标记，如上文代码；
InterfaceInterceptor：在接口的方法上进行标记，如上文代码；

代码下载：ConsoleApplication1.rar，ConsoleApplication2.rar