.NET remoting 通道接收器扩展（读书笔记）

1. 远程对象代理，消息接收器的概念

当客户端发起一个远程调用后，透明代理为该远程调用生成一个 IMessage 对象，并将它传给实际代理。之后，实际代理会查询特定远程对象相关的配置信息，再决定加载哪些消息接收器来处理该远程调用。代理把IMessage对象传给消息接收器来处理该远程调用。

实际代理至少需要加载两个消息接收器。
1. 格式转换接收器(binary和soap)，负责将IMessage对象序列化为数据流，最终再由网络传送出去。
2. 传送接收器(http和tcp)，负责把数据流输送到目的地或远程服务器。

PS  透明对象和真实对象的关系
Activator.GetObject()和Activator.CreateInstance()返回给客户一个代理对象。实际上得到两个代理对象，透明代理和真实代理。透明代理像远程对象，它执行远程对象的所有公共方法，这些方法调用真实对象的Invoke()方法，传送包含方法调用的消息。

消息流动：
--call-->【透明对象】--IMessage-->【实际代理】--IMessage2-->【消息接收器】（在一个调用中，编码>>自定义前期操作>>传送到远端 >>收到应答>>自定操作后续操作>>解码）
参与对象：
RealProxy，IMessage，IClientChannelSink

2. 消息接收器实现

类1. 实现 IClientChannelSinkProvider 接口，为远程处理消息从其流过的客户端信道创建客户端信道接收器。
类2.
继承 BaseChannelSinkWithProperties，提供希望向其属性公开字典接口的信道接收器的基实现。  
实现 IClientChannelSink 接口，为客户端信道接收器提供所需的函数和属性。同步调用，消息是通过其ProcessMessage()接口中流动(调用流动：被调用，做完前期工作，然后调用下一个槽位；返回流：下一个槽位对象的ProcessMessage方法调用返回后，当前槽对象继续做后续工作然后返回，让栈中的下一位继续处理。最终在对象中来回流动一次把结果返回给代理)。

 

.Net Remoting 相关接口介绍

Channel:信道/通道

Sink:接收器

 

BaseChannelSinkWithProperties

BaseChannelWithProperties

BaseChannelSinkWithProperties/BaseChannelWithProperties --> BaseChannelObjectWithProperties  -->  IDictionary

BaseChannelObjectWithProperties 是 BaseChannelWithProperties 和 BaseChannelSinkWithProperties 的基类。

BaseChannelWithProperties 和 BaseChannelSinkWithProperties 可用作提供已命名属性的信道和信道接收器的基类。

BaseChannelObjectWithProperties 处理向信道对象请求其属性的复杂任务。

其中BaseChannelWithProperties对properties作了重写,以遍律服务端或客户端的所有信道接收器.

 

IChannelSinkBase

IChannelSinkBase:为信道接收器提供基接口.提供IDictionary Properties属性, 获取可以通过其访问接收器的属性的字典.

IClientChannelSink

IClientChannelSink --> IChannelSinkBase:为客户端信道接收器提供所需的函数和属性.

信道接收器提供插件点，该插件点允许访问流过该信道的基础消息，还允许访问传输机制用来将消息发送到远程对象的流。信道接收器在信道接收器提供程序链中链接在一起，在消息被序列化并传输之前，所有信道消息都流过该接收器链。

IServerChannelSink

IServerChannelSink -->  IChannelSinkBase:提供用于安全和传输接收器的方法.

信道接收器提供插件点，该插件点允许访问流过该信道的基础消息，还允许访问传输机制用来将消息发送到远程对象的流。信道接收器在信道接收器提供程序链中链接在一起，并且所有信道消息在被序列化和传输之前都要流过此接收器链。

IChannel

IChannel:为跨远程处理边界的消息提供管道。

远程处理边界可以是 Context、AppDomain、进程或计算机。应用程序只能使用信道来跨越这些边界。这些交叉可以是入站和出站的。信道可以在终结点上侦听入站消息，向终结点发送出站消息，或同时进行这两种操作。这在运行库中提供一个可扩展性点，以便插入各种协议，即使运行库可能并不在信道的另一端。

运行库对象可用于表示广泛丰富的语义和实体集。信道提供可扩展性点以将消息在特定协议间来回转换。如果信道的两端都有运行库，则将在两个端点之间建立一个虚拟信道，以连接边界两侧的客户端和服务器接收器链。

信道的客户端部分位于客户端上下文接收器链的末尾。信道的服务器部分位于服务器上下文接收器链的起点。使用 IMessageSink 接口将消息传送到客户端信道，消息通过该信道，然后被服务器信道接收。服务器信道将消息传送到第一个服务器上下文接收器。

信道必须公开 IChannel 接口，该接口提供信息性的属性，例如 ChannelName 和 ChannelPriority 属性。可以使用 ChannelServices.RegisterChannel 方法注册信道。

IChannelSender

IChannelSender --> IChannel:为发送方信道提供所需的函数和属性。

IChannelReceiver

IChannelReceiver --> IChannel:为接收器信道提供所需的函数和属性。

IClientChannelSinkProvider

IClientChannelSinkProvider:为远程处理消息从其流过的客户端信道创建客户端信道接收器。

信道接收器通过 IClientChannelSinkProvider 接口的实现连接到客户端信道。所有远程处理客户端信道均提供以 IClientChannelSinkProvider 为参数的构造函数。

信道接收器提供程序存储在一个链中，在向信道构造函数传递外部信道接收器提供程序之前，用户负责将所有的信道接收器提供程序链接在一起。为此，IClientChannelSinkProvider 提供了名为 Next 的属性。

在一个配置文件中指定了多个信道接收器提供程序后，远程处理基础结构将这些提供程序按它们在配置文件中的顺序链接起来。在 RemotingConfiguration.onfigure 调用过程中创建信道时，将创建信道接收器提供程序。

IServerChannelSinkProvider

IServerChannelSinkProvider:为远程处理消息从其流过的服务器信道创建服务器信道接收器。

信道接收器通过 IServerChannelSinkProvider 接口的实现连接到服务器信道。所有远程处理服务器信道均提供以 IServerChannelSinkProvider 为参数的构造函数。

信道接收器提供程序存储在一个链中，在向信道构造函数传递外部信道接收器提供程序之前，用户负责将所有的信道接收器提供程序链接在一起。为此，IServerChannelSinkProvider 提供了名为 Next 的属性。

在一个配置文件中指定了多个信道接收器提供程序后，远程处理基础结构将这些提供程序按它们在配置文件中的顺序链接起来。在 RemotingConfiguration.Configure 调用的过程中，信道接收器提供程序和信道同时创建。

在生成 IMethodCallMessage 之后，.NET Framework 搜索注册信道的列表以查找一个可以处理该调用的信道。一旦找到适当的信道之后，便从该信道检索信道接收器，并将 IMethodCallMessage 转发到接收器以进行处理。

 

using  System;
using  System.Runtime.Remoting;
using  System.Runtime.Remoting.Channels;
using  System.Runtime.Remoting.Messaging;
using  System.IO;
using  SAF.Configuration;
using  System.Configuration;
using  System.Collections;
using  System.Threading;

namespace  SAF.Cryptography
... {
/**//// <summary>
/// CryptoRemotingServerSink represents the remoting sink on the server.
/// It enables the secure data transmitted via .NET remoting
/// </summary>
public class CryptoRemotingServerSink : BaseChannelSinkWithProperties, IServerChannelSink
...{
    private IServerChannelSink next;
    private  static ConfigurationManager cm = (ConfigurationManager)ConfigurationSettings.GetConfig("Framework");
    private  static CryptographyConfiguration cc = cm.CryptographyConfig;
    private CryptoRemotingSinkHelper helper = new CryptoRemotingSinkHelper();
    private const string sinkType = "ServerSink";

    public CryptoRemotingServerSink()
    ...{
    }


    /**//// <summary>
    /// ProcessMessage decrypts the data stream and forward it the target 
    /// server object and encrypts the return value
    /// </summary>
    /// <param name="sinkStack">channel sink object</param>
    /// <param name="requestMsg">IMessage object</param>
    /// <param name="transportHeaders">transport header object</param>
    /// <param name="targetStream">requrest stream</param>
    /// <param name="responseMsg">output parameters containing response message</param>
    /// <param name="responseHeaders">output parameter containing the response header</param>
    /// <param name="responseStream">output parameter containing the response stream</param>
    /// <returns></returns>
    public ServerProcessing ProcessMessage(
        IServerChannelSinkStack sinkStack, IMessage requestMsg, ITransportHeaders transportHeaders, Stream targetStream, 
        out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream)
    ...{
        
        //extract the identity information from the header
        string identity = transportHeaders["Identity"].ToString();
        LocalDataStoreSlot dataSlot = null;
        //create an thread data slot
        dataSlot = Thread.GetNamedDataSlot("Identity");

        //add the identity informatioin to the data slot on the thread so that
        //server object can determine who made the request.
        Thread.SetData(dataSlot,identity);
        // Push this onto the sink stack
        sinkStack.Push(this, null);

        //decrypt the request stream
        Stream decryptedStream = helper.DecryptStream(identity,sinkType,transportHeaders,targetStream);
        ServerProcessing processingResult;
    
        //pass the decrypted request to next sink of the chain
        processingResult = next.ProcessMessage(
            sinkStack, requestMsg, transportHeaders, decryptedStream,
            out responseMsg, out responseHeaders, out responseStream);
        
        
        //encrypte the response stream.
        Stream encryptedStream = helper.EncryptStream(identity,sinkType,responseHeaders,responseStream);
        string serverIdentity = cc.GetServerSinkIndentity();
        responseHeaders["Identity"] = serverIdentity;
        responseStream  = encryptedStream;
                    
        return processingResult;
    }

    public void AsyncProcessResponse(
        IServerResponseChannelSinkStack sinkStack, object state, IMessage msg, ITransportHeaders headers, Stream stream)
    ...{
        throw new RemotingException("AsyncProcessRequest is not enabled yet");
    }
    public CryptoRemotingServerSink(IServerChannelSink nextSink)
    ...{
        next = nextSink;
    }

    public Stream GetResponseStream(
        IServerResponseChannelSinkStack sinkStack, object state, IMessage msg, ITransportHeaders headers)
    ...{
        //not implemented, since only formatter sink need to call this method
        return null;
    }
    public IServerChannelSink NextChannelSink
    ...{
        get ...{ return next; }
    }
}

/**//// <summary>
/// provider class for the server sink class
/// </summary>
public class CryptoRemotingServerSinkProvider : IServerChannelSinkProvider
...{
    private IServerChannelSinkProvider next;
    public CryptoRemotingServerSinkProvider(IDictionary properties, ICollection providerData)
    ...{
    }


    public IServerChannelSinkProvider Next
    ...{
        get ...{ return next; }
        set ...{ next = value; }
    }
    public void GetChannelData(IChannelDataStore channelData)
    ...{
    }
    /**//// <summary>
    /// factory method that create the concrete corresponding server sink object
    /// </summary>
    /// <param name="channel">The channel for which to create the channel sink chain. </param>
    /// <returns>newly created CryptoRemotingServerSink object</returns>
    public IServerChannelSink CreateSink(IChannelReceiver channel)
    ...{
        IServerChannelSink nextSink;
        nextSink = next.CreateSink(channel);
        return new CryptoRemotingServerSink(nextSink);
    }
}


}

     < system .runtime.remoting >
         < application >     
             < client >
                 < wellknown 
                     type ="Test.BusinessLibrary.SampleBusiness, Test.BusinessLibrary"  
                    url ="http://localhost:4000/SampleBusiness.rem"
                 />
             </ client >
             < channels >
                 < channel  ref ="http" >
                     < clientProviders >
                         < formatter  ref ="binary"   />
                         < provider
                             type ="SAF.Cryptography.CryptoRemotingClientSinkProvider, SAF.Cryptography"
                         />
                     </ clientProviders >
                 </ channel >
             </ channels >

         </ application >
     </ system.runtime.remoting >

 利用.NET Remoting基础架构中的真实代理/透明代理技术实现了不针对具体类型、具体方法的通用方法调用拦截机制

using  System;
using  System.Runtime.Remoting ;
using  System.Runtime.Remoting.Services ;

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

namespace  TTester
... {
    /**//**//**//
    public class Calculator : MarshalByRefObject
    ...{
        private Calculator() ...{ }
 
        public static Calculator CreateInstance()
        ...{
            MessageChainProxy realProxy = new MessageChainProxy(new Calculator());
            realProxy.AppendSinkType(typeof(LogAspect));
            Object transparentProxy = realProxy.GetTransparentProxy();
            return (Calculator)transparentProxy;
        }
 
        public int Add(int x, int y)
        ...{
            return x + y;
        }
    }
    /**//**//**//
    public class MessageChainProxy : RealProxy
    ...{
        private class TerminatorSink : IMessageSink
        ...{
            private MarshalByRefObject m_target;
 
            public TerminatorSink(MarshalByRefObject target)
            ...{
                this.m_target = target;
            }
 

 
            public IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink)
            ...{
                throw new Exception("The method or operation is not implemented.");
            }
 
            public IMessageSink NextSink
            ...{
                get ...{ return null; }
            }
 
            public IMessage SyncProcessMessage(IMessage msg)
            ...{
                return RemotingServices.ExecuteMessage(m_target, msg as IMethodCallMessage);
            }
        }
 

 
        private MarshalByRefObject m_target;
        private IMessageSink headSink;
 
        public MessageChainProxy(MarshalByRefObject target): base(target.GetType())
        ...{
            this.m_target = target;
            headSink = new TerminatorSink(m_target);
        }
 
        public override IMessage Invoke(IMessage msg)
        ...{
            return headSink.SyncProcessMessage(msg);
        }
 
        public void AppendSinkType(Type sinkType)
        ...{
            object[] ctorArgs = new object[] ...{ headSink };
            IMessageSink newSink = (MessageSinkBase)Activator.CreateInstance(sinkType, ctorArgs);
            headSink = newSink;
        }
    }
    /**//**//**//////
    public abstract class MessageSinkBase : IMessageSink
    ...{
        private readonly IMessageSink m_nextSink;
 
        public MessageSinkBase(IMessageSink nextSink)
        ...{
            m_nextSink = nextSink;
        }
 

 
        public virtual IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink)
        ...{
            return m_nextSink.AsyncProcessMessage(msg, replySink);
        }
 
        public IMessageSink NextSink
        ...{
            get ...{ return m_nextSink; }
        }
 
        public abstract IMessage SyncProcessMessage(IMessage msg);
 

    }
    /**//**//**///
    public class LogAspect : MessageSinkBase
    ...{
        public LogAspect(IMessageSink nextSink)
            : base(nextSink)
        ...{
        }
 
        public override IMessage SyncProcessMessage(IMessage msg)
        ...{
            IMethodCallMessage callMsg = msg as IMethodCallMessage;
 
            DateTime callTime = DateTime.Now;
            IMessage returnMsg = NextSink.SyncProcessMessage(msg);
            DateTime retTime = DateTime.Now;
            IMethodReturnMessage retMsg = returnMsg as IMethodReturnMessage;
 
            TimeSpan tspan = callTime.Subtract(retTime);
            string[] strs = callMsg.TypeName.Split(new char[] ...{ ',', '.' });
            string clsName = null;
            if (strs.Length >= 2)
            ...{
                clsName = strs[1];
            }
 
            Console.WriteLine("[" + callTime + "] " +
                clsName +
                "." +
                callMsg.MethodName +
                "(" +
                callMsg.InArgs[0] +
                "," +
                callMsg.InArgs[1] +
                ") " +
                "-(" +
                tspan.TotalMilliseconds * 1000000 +
                "ns)-> " +
                retMsg.ReturnValue
                );
 
            return returnMsg;
        }
    }

/**//*
  本程序说明了截获是如何进行的，以及真实代理和透明代理之间的关系及交互。
*/

    class Class1
    ...{  
        private static string[] gg=...{"sdf", "fsddx"};
        [STAThread]
        static void Main(string[] args)
        ...{
            Calculator t = Calculator.CreateInstance();
            t.Add(123,2);

        }
    
    }
}

调用栈
TTester.Calculator.Add(int x = 0x7b, int y = 0x2) Line 25    C#
     [<Non-user Code>]   
TTester.MessageChainProxy.TerminatorSink.SyncProcessMessage()
TTester.LogAspect.SyncProcessMessage()
TTester.MessageChainProxy.Invoke()
     [<Non-user Code>]   
TTester.Class1.Main(string[] args = {Length=0x0})