DynamicProxy(动态代理)技术剖析(2)

在写完上篇文章《DynamicProxy(动态代理)技术剖析(1)》后,才发现原来博客园的dudu、hbifts、steeven早在一年前就开始制作AOP.NET了。谢谢hbifts的指导,让我又找到了不少有用的资料。

今天,仍然继续上次话题,把DynamicProxy的Mixins技术和IInvocation接口介绍一下:

上次只说道IInvocation接口中包含了一个回调的Delegate。但IInvocation接口提供的东西要更多,先让我们看看它的定义:

public   interface  IInvocation
{
  
object Proxy get; }
  
object InvocationTarget get;set; }
  MethodInfo Method 
get; }
  
object Proceed( params object[] args );
}

在这里我们关键讨论一下Proxy属性以及Proceed方法。Proxy提供了对动态生成的DynamicProxy对象的一个引用。而Proceed方法便是对原有方法的"回调"操作。让我们看看在DynamicProxy中提供的一个实现:

namespace  Castle.DynamicProxy.Invocation
{
  
using System.Reflection;

  
public abstract class AbstractInvocation : IInvocation
  
{
    
protected ICallable _callable;
    
protected object _original_target;
    
private MethodInfo _method;
    
private object _proxy;
    
private object _target;

    
public AbstractInvocation( ICallable callable, object proxy, MethodInfo method )
    
{
      _callable 
= callable;
      _proxy 
= proxy;
      _target 
= _original_target = callable.Target;
      _method 
= method;
    }


    
public object Proxy
    
get return _proxy; } }

    
public object InvocationTarget
    
{
      
get return _target; }
      
set { _target = value; }
    }


    
public MethodInfo Method
    
get return _method; } }

    
public abstract object Proceed(params object[] args);
  }

  
  
public class SameClassInvocation : AbstractInvocation
  
{
    
public SameClassInvocation(ICallable callable, object proxy, MethodInfo method) : 
      
base(callable, proxy, method)
    
{
    }


    
public override object Proceed(params object[] args)
    
{
      
// If the user changed the target, we use reflection
      
// otherwise the delegate will be used.
      if (InvocationTarget == _original_target)
        
return _callable.Call( args );
      
else
        
return Method.Invoke(InvocationTarget, args);
    }

  }

}

我们可以看到在AbstractInvocation的构造函数中接收一个ICallable类型的参数。我们在上篇文章中提到的代理便实现了ICallable接口(这也是动态生成的代码所实现的)。另外,注意SameClassInvocation类中的Proceed方法,便是调用代理所对应的原有方法。如果用户改变了调用对象的化,也可以通过反射实现同样的功能(看来是双保险)。

了解了这些后,我们可以借助IInvocation接口提供的这些信息实现更复杂的操作。还记得上次说到的拦截器吗?其中一段定义如下:

   public   class  StandardInterceptor : IInterceptor
  
{
    
public StandardInterceptor(){}
   
protected virtual void PreProceed(IInvocation invocation, params object[] args){}
       ……

PreProceed与PostProceed都接收一个IInvocation类型的对象,我们可以使用invocation.Proxy获取对DynamicProxy对象的一个引用,然后通过强制类型转换转换成希望的类型,再进行一些具体操作……,就不用我细说了吧。

了解了IInvocation后,我们再来看看DynamicProxy提供的Mixins功能。Mixins允许我们将某个合并类和另外一个被合并类"合并"起来,并以此来为被合并类添加新的功能。除此之外,为了确保能够调用到合并后的类的具体方法,最好将让被合并类实现某个接口,这样就可以通过类型转换达到调用目的。还是看一段代码吧:

public   interface  ISimpleMixin
{
  
void DoSomethingInMixin();
}


[Serializable]
public   class  SimpleMixin : ISimpleMixin
{
  
public SimpleMixin()
  
{
  }


  
public void DoSomethingInMixin()
  
{
    Console.WriteLine(
"This is in Mixin Method.");
  }

}


public   class  MainClient
{
  
public static void Main()
  
{
    ProxyGenerator _generator 
= new ProxyGenerator();
    GeneratorContext context 
= new GeneratorContext();
    SimpleMixin mixin_instance 
= new SimpleMixin();
    context.AddMixinInstance( mixin_instance );

    TimeUsedInterceptor interceptor 
= new TimeUsedInterceptor();

    
object proxy = _generator.CreateCustomClassProxy( typeof(SimpleClass), interceptor, context );
    
    ((SimpleClass) proxy).DoSomething();
    ((ISimpleMixin) proxy).DoSomethingInMixin();

    Console.ReadLine();
  }

}

SimpleMixin类实现了ISimpleMixin接口,该接口只有一个方法DoSomethingInMixin。在主程序中,我们可以将Mixins添加到GeneratorContext对象后提供给ProxyGenerator对象进行"合并"生成,于是产生出来的proxy对象就既有SimpleClass提供的方法,又有SimpleMixin提供的方法。我们可以将proxy对象分别转换成对应的SimpleClass类型与ISimpleMixin类型来调用其中的方法。

在研究学习时发现,尽管合并后就成为一个对象了,但SimpleClass与Mixin之间无法互相访问受保护成员与私有成员。因为"合并"是动态生成的,在合并前,两者无法相互访问私有成员,这在编译上是通不过的。但是相互间却可以访问公有成员。这要稍微麻烦一些,我们可以通过改进设计来实现,最终代码可能会象这样:

((ISimpleMixin) proxy).DoSomethingInMixin((SimpleClass) proxy);

于是ISimpleMixin便访问到了SimpleClass成员,其实都是一回事,都是proxy。

关于DynamicProxy的技术剖析到这里就结束了。本人下一步决定学习一下AOP。有时间再写些东西上来。

你可能感兴趣的:(dynamic)