.NET ：消息与AOP

一.基本知识点

方法调用与消息

 如果一个目标对象委托给一个真实代理实例，那么所有对对应的透明代理的方法调用都会经过一个消息转换与反转换的过程，而 正是将方法调用转换为消息后，我们才有机会实现预（后）处理，这样更进一步的结果是 ＝＝》 实现所谓的AOP。

1． 真实代理：从RealProxy派生，最主要的是复写Invoke方法。Invoke方法的主要职能是为截获方法调用加上预（后）处理，以此来实现AOP。
（1） 一种真实代理类型就表示一种特定的预（后）处理，如果一个类希望自己的公共方法被外界调用时进行适当的预处理或后处理，   那么该类可以将自己的实例委托给有此预（后）处理功能的真实代理。
（2） 真实代理实例与透明代理实例是一一对应的。不存在透明代理的类，但是却可以从真实代理实例得到透明代理。
（3） 透明代理：将方法调用转换为消息（实际被转换的是堆栈帧）。针对透明代理调用目标对象的方法，会被最终转发到目标对象上。在使用层面上来看，可以将透明代理当作目标对象本身。
（4） Stack Builder Sink ：将消息转换为方法调用，并返回调用结果给代理，再由代理将结果转为响应消息通过RPC传递，然后在将响应消息转换为调用后的堆栈，这样原调用方便可得到调用结果。
（5） 针对不同的预（后）处理，可以定义不同的真实代理类型。

2． 如果一个类（比如class Example）希望外界调用它的公共方法（包括ctor）时，通过代理来完成（主要目的是实现某种特定 的预/后处理），那么有两种方法来实现：
（1） 将Example以工厂方法的模式实现，这样在其static Instance方法中，可以将一个新实例的引用委托给一个实现特定预处理和   后处理的真实代理。接着将该代理的透明代理强制转换为该类引用，并返回它。此处情况下，真实代理类型仅需从RealProxy一   个类派生。
（2） 通过代理特性（一种特殊的真实代理）实现。
  首先，代理特性类型必须从ProxyAttribute派生，此时有两个方法需要复写，一个是Invoke方法，另一个是CreateInstance方法。
      Example必须从ContextBoundObject派生，即Example必须为一个上下文绑定对象，另外，为Example类加上代理特性。在该情况下，对象激活（即new Example时）被分为两个阶段，首先调用真实代理的CreateInstance方法，生成一个未初始化的对象；接着在将ctor转发给真实代理的Invoke方法。
      注意，对不是从ContextBoundObject类派生的类实施上下文特性（即代理特性），也无法实现截获。

（1）和（2）的比较：（1）中将目标对象委托给代理是Example自己的职责，而（2）中把该职责转移到代理中去了。

其它说明：

1. 上下文特性修饰一个类，以后每次new这个类产生对象时，都将对象放入相应的上下文中。
2. 上下文特性与上下文属性通常是一一对应的。
3. 上下文特性在创建时将上下文属性添加到上下文中，更确切说，是这样的，上下文特性检查当前上下文中
    是否存在要添加的属性，并且存在的属性值与要添加的属性值是否相等，如果两者都满足，则直接在该上
    下文中创建新实例。否则，上下文特性将要求对象ctor创建一个新的上下文包含所要添加的属性。
4. 一个上下文可以包含多个不同的上下文属性，每一组确定的上下文属性值即可确定一个上下文。

5.  消息接收器本身可以作为任何种类的接收器，关键是看上下文属性将其安排为何种接收器（如，信使接收器，服务器上下文接收器）

6. 上下文（context）是存在于当前应用域中的，用于将该上下文中的属性转换为接收器插入到该上下文中的对象的方法调用过程中。
      而调用上下文（call context）是存在于消息接收器链中的，用于在链中传递信息。
         

二.程序示例

using System;
using System.Runtime.Remoting ;
using System.Runtime.Remoting.Services ;
using System.Runtime.Remoting.Activation ;
using System.Runtime.Remoting.Proxies ;
using System.Runtime.Remoting.Messaging ;

/*
  本程序说明了截获是如何进行的，以及真实代理和透明代理之间的关系及交互。
*/
namespace Intercept_example
{
 class Class1
 {  
  [STAThread]
  static void Main(string[] args)
  {
   Example exa = new Example("sky" ) ;
   exa.say_hello() ;
  }
 } 
 
 //定义一个真实代理，用于实现一个特定的预处理和后处理
 public class InterceptProxy :  RealProxy
 {
  private readonly MarshalByRefObject target ;
  
  public InterceptProxy(MarshalByRefObject obj ,Type type) :base(type)
  {
   this.target = obj ;
  }

  
  public override IMessage Invoke(IMessage msg)
  {
   IMethodCallMessage call = (IMethodCallMessage)msg ;
   
   //如果触发的是构造函数，此时target的构建还未开始
   IConstructionCallMessage ctor = call as IConstructionCallMessage ;
   if(ctor != null)
   {
    System.Console.WriteLine("转发构造函数调用！") ;

    RealProxy default_proxy = RemotingServices.GetRealProxy(this.target) ;

    default_proxy.InitializeServerObject(ctor) ;
    MarshalByRefObject tp = (MarshalByRefObject)this.GetTransparentProxy() ;

    return EnterpriseServicesHelper.CreateConstructionReturnMessage(ctor,tp);
    
   }

   System.Console.WriteLine("预处理中......") ;
   System.Threading.Thread.Sleep(5000) ;
   
   IMethodReturnMessage result_msg = RemotingServices.ExecuteMessage(this.target ,call) ;
   
   System.Console.WriteLine("后处理中......") ;
   System.Threading.Thread.Sleep(5000) ;
   System.Console.WriteLine("后处理结束！") ;

   return result_msg ;

  }
 }
  
 

 //定义一个特性，该特性可以将上面的真实代理与运用该特性的class联系起来
 [AttributeUsage(AttributeTargets.Class)]
 public class InterceptProxyAttribute : ProxyAttribute
 {
  //得到透明代理
  public override MarshalByRefObject CreateInstance(Type serverType)
  {
   //未初始化的实例
   MarshalByRefObject target =  base.CreateInstance (serverType);

   InterceptProxy rp = new InterceptProxy(target ,serverType) ;

   return (MarshalByRefObject)rp.GetTransparentProxy() ;
  }
 }

 [InterceptProxy]
 public class Example : ContextBoundObject//放到特定的上下文中，该上下文外部才会得到该对象的透明代理
 {
  private string name ;
  public Example(string a)
  {
   this.name = a ;
  }

  public void say_hello()
  {
   Console.WriteLine("hello ! " + name ) ;
  }
 }

 /*
  *（1） 当调用方和被调方位于不同的上下文时，调用方得到的是被调对象的透明代理。透明代理会将方法调用打包成一个IMessage对象，并传给实际代理的Invoke方法。
  *     Invoke方法的默认实现只是将IMessage对象传递到后面的通道（如堆栈生成器等）中。我们可以定制自己的真实代理，重写Invoke方法，为之加上预处理和后处理。
  *（2）通过代理特性（如InterceptProxyAttribute）（从ProxyAttribute继承）将真实代理与目标class关联起来。这个代理特性主要重写ProxyAttribute的CreateInstance
  *    CreateInstance方法，在该方法中，在目标对象的外围包裹上真实代理（如InterceptProxy），而返回该真实代理的透明代理。
  * （3）在程序中，不能直接通过真实代理来调用目标对象的方法，因为真实代理处理的是消息对象（IMessage），它是基于消息世界的。
  * （4）只有持有透明代理的引用，我们才有可能加入截获（前处理和后处理）。
  * （5）派生于ContextBoundObject的类，我们只能得到它的透明代理；派生于MashalByRefObject的类的对象，我们可能得到它的透明代理或者直接引用，这取决于被调方和目
  *  标对象是否位于同一上下文中；不从这两个类派生的类的对象，我们只能得到它的直接引用。
  */

 
}