.Net中Remoting通信机制

Remoting通信机制

  • Remoting介绍
  • 主要元素
  • 通道类型
  • 激活方式
  • 对象定义

Remoting介绍

什么是Remoting，简而言之，我们可以将其看作是一种分布式处理方式。

从微软的产品角度来看，可以说Remoting就是DCOM（分布式组件对象模型,分布式组件对象模式）的一种升级，它改善了很多功能，并极好的融合到.Net平台下。Microsoft .NET Remoting 提供了一种允许对象通过应用程序域与另一对象进行交互的框架。这也正是我们使用Remoting的原因。为什么呢？在Windows操作系统中，是将应用程序分离为单独的进程。这个进程形成了应用程序代码和数据周围的一道边界。如果不采用进程间通信（IPC）机制，则在一个进程中执行的代码就不能访问另一进程。这是一种操作系统对应用程序的保护机制。然而在某些情况下，我们需要跨过应用程序域，与另外的应用程序域进行通信，即穿越边界。

Remoting通信框架图：

在Remoting中是通过通道（channel）来实现两个应用程序和域之间对象的通信的。首先，客户端通过Remoting，访问通道以获得服务端对象，再通过代理解析为客户端对象。这就提供一种可能性，即以服务的方式来发布服务器对象。远程对象代码可以运行在服务器上（如服务器激活的对象和客户端激活的对象），然后客户端再通过Remoting连接服务器，获得该服务对象并通过序列化在客户端运行。

在Remoting中，对于要传递的对象，设计者除了需要了解通道的类型和端口号之外，无需再了解数据包的格式。这既保证了客户端和服务器端有关对象的松散耦合，同时也优化了通信的性能。

主要元素

  • 远程对象——远程对象是运行在服务器上的对象。客户端不能直接调用远程对象上的方法，而要使用代理。使用.NET，很容易把远程对象和本地对象区分开：即任何派生自 MarshalByRefObject 的类从来都不会离开它的应用程序域。客户端可以通过代理调用远程对象的方法。
  • 信道——信道用于客户端和服务器之间的通信。信道包括客户端的信道部分和服务器的信道部分。.NET Framework 4 提供了 3 种信道类型，它们分别通过 TCP、HTTP 和IPC 进行通信。此外，还可以创建自定义信道，这些信道使用其他协议通信。
  • 消息——消息被发送到信道中。消息是为客户端和服务器之间的通信而创建的。消息包含远程对象的信息、被调用方法的名称以及所有的参数。
  • 格式化程序——格式化程序用于定义消息如何传输到信道中。.NET 4 有SOAP 格式化程序和二进制格式化程序。使用 SOAP 格式化程序可以与不是基于.NET Framework 的Web 服务通信。二进制格式化程序速度更快，可以有效地用在内部网环境中。当然，也可以创建自定义格式化程序。
  • 格式化程序提供程序——格式化程序提供程序用于把格式化程序与信道关联起来。通过创建信道，可以指定要使用的格式化程序提供程序，格式化程序提供程序则定义把数据传输到信道中时所使用的格式化程序。
  • 代理——客户端调用代理的方法，而不是远程对象的方法。代理分为两种：透明的代理和真实的代理。对于客户端，透明代理看起来与远程对象类似。在透明代理上，客户端可以调用远程对象实现的方法。然后，透明代理调用真实代理上的 Invoke()方法。Invoke()方法使用消息接收器把消息传递给信道。
  • 消息接收器——消息接收器是一个侦听器(interceptor)对象，简称接收器。在客户端和服务器上都有侦听器。接收器与信道相关联。真实的代理使用消息接收器把消息传递到信道中，因此，在消息进入信道之前，接收器可以进行截获工作。根据接收器所处的位置，可以把接收器称为特使接收器(envoy sink)、服务器上下文接收器、对象上下文接收器等。
  • 激活器——客户端可以使用激活器在服务器上创建远程对象，或者获取一个被服务器激活的对象的代理。
  • RemotingConfiguration 类——该类是用于配置远程服务器和客户端的一个实用程序类。它可以用于读取配置文件或动态地配置远程对象。
  • ChannelServices 类——该类是一个实用程序类，可用于注册信道并把消息分配到信道中

通道类型

Remoting的通道主要有两种：Tcp和Http。

在.Net中，System.Runtime.Remoting.Channels中定义了 IChannel接口。IChannel接口包括了TcpChannel通道类型和Http通道类型。

它们分别对应Remoting通道的这两种类型。

TcpChannel

　　TcpChannel类型放在名字空间System.Runtime.Remoting.Channels.Tcp中。Tcp通道提供了基于Socket 的传输工具，使用Tcp协议来跨越Remoting边界传输序列化的消息流。TcpChannel类型默认使用二进制格式序列化消息对象，因此它具有更高的传输性能。

HttpChannel

　　HttpChannel类型放在名字空间System.Runtime.Remoting.Channels.Http中。它提供了一种使用 Http协议，使其能在Internet上穿越防火墙传输序列化消息流。默认情况下，HttpChannel类型使用Soap格式序列化消息对象，因此它具有更好的互操作性。通常在局域网内，我们更多地使用TcpChannel；如果要穿越防火墙，则使用HttpChannel。

激活方式

在访问远程类型的一个对象实例之前，必须通过一个名为Activation的进程创建它并进行初始化。这种客户端通过通道来创建远程对象，称为对象的激活。

在Remoting中，远程对象的激活分为两大类：服务器端激活和客户端激活。

服务端激活：

　　服务器端激活，又叫做WellKnow方式，很多又翻译为知名对象。为什么称为知名对象激活模式呢？是因为服务器应用程序在激活对象实例之前会在一个众所周知的统一资源标识符(URI)上来发布这个类型。然后该服务器进程会为此类型配置一个WellKnown对象，并根据指定的端口或地址来发布对象。

. Net Remoting把服务器端激活又分为SingleTon模式和SingleCall模式两种。

　　SingleTon模式：此为有状态模式。如果设置为SingleTon激活方式，则Remoting将为所有客户端建立同一个对象实例。当对象处于活动状态时， SingleTon实例会处理所有后来的客户端访问请求，而不管它们是同一个客户端，还是其他客户端。SingleTon实例将在方法调用中一直维持其状态。举例来说，如果一个远程对象有一个累加方法（i=0；++i），被多个客户端（例如两个）调用。如果设置为SingleTon方式，则第一个客户获得值为1，第二个客户获得值为2，因为他们获得的对象实例是相同的。如果熟悉Asp .Net的状态管理，我们可以认为它是一种Application状态。

　　SingleCall模式：SingleCall是一种无状态模式。一旦设置为SingleCall模式，则当客户端调用远程对象的方法时， Remoting会为每一个客户端建立一个远程对象实例，至于对象实例的销毁则是由GC自动管理的。同上一个例子而言，则访问远程对象的两个客户获得的都是1。我们仍然可以借鉴Asp .Net的状态管理，认为它是一种Session状态。

客户端激活：

　　客户端激活。与WellKnown模式不同， Remoting在激活每个对象实例的时候，会给每个客户端激活的类型指派一个URI。客户端激活模式一旦获得客户端的请求，将为每一个客户端都建立一个实例引用。

　　SingleCall模式和客户端激活模式是有区别的：首先，对象实例创建的时间不一样。客户端激活方式是客户一旦发出调用的请求，就实例化；而SingleCall则是要等到调用对象方法时再创建。其次，SingleCall模式激活的对象是无状态的，对象生命期的管理是由GC管理的，而客户端激活的对象则有状态，其生命周期可自定义。其三，两种激活模式在服务器端和客户端实现的方法不一样。尤其是在客户端，SingleCall模式是由 GetObject()来激活，它调用对象默认的构造函数。而客户端激活模式，则通过CreateInstance()来激活，它可以传递参数，所以可以调用自定义的构造函数来创建实例。

对象定义

前面讲到，客户端在获取服务器端对象时，并不是获得实际的服务端对象，而是获得它的引用。因此在Remoting中，对于远程对象有一些必须的定义规范要遵循。

由于Remoting传递的对象是以引用的方式，因此所传递的远程对象类必须继承MarshalByRefObject。MSDN对 MarshalByRefObject的说明是：MarshalByRefObject 是那些通过使用代理交换消息来跨越应用程序域边界进行通信的对象的基类。不是从 MarshalByRefObject 继承的对象会以隐式方式按值封送。当远程应用程序引用一个按值封送的对象时，将跨越远程处理边界传递该对象的副本。因为您希望使用代理方法而不是副本方法进行通信，因此需要继承MarshallByRefObject。

在Remoting中能够传递的远程对象可以是各种类型，包括复杂的DataSet对象，只要它能够被序列化。远程对象也可以包含事件，但服务器端对于事件的处理比较特殊，我将在本系列之三中介绍。

服务器

根据第一部分所述，根据激活模式的不同，通道类型的不同服务器端的实现方式也有所不同。大体上说，服务器端应分为三步：

1、注册通道

　　要跨越应用程序域进行通信，必须实现通道。如前所述，Remoting提供了IChannel接口，分别包含TcpChannel和HttpChannel两种类型的通道。这两种类型除了性能和序列化数据的格式不同外，实现的方式完全一致，因此下面我们就以TcpChannel为例。

注册TcpChannel，首先要在项目中添加引用“System.Runtime.Remoting”，然后using名字空间：System.Runtime.Remoting.Channels.Tcp。

比如：

using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Tcp;

代码如下：

1 TcpChannel channel = new TcpChannel(8080);
2 ChannelServices.RegisterChannel(channel);

在实例化通道对象时，将端口号作为参数传递。然后再调用静态方法RegisterChannel()来注册该通道对象即可。

2、远程对象

注册了通道后，要能激活远程对象，必须在通道中注册该对象。根据激活模式的不同，注册对象的方法也不同。

(1) SingleTon模式

　　对于WellKnown对象，可以通过静态方法RemotingConfiguration.RegisterWellKnownServiceType()来实现：

1 RemotingConfiguration.RegisterWellKnownServiceType(
2 typeof(ServerRemoteObject.ServerObject),
3 "ServiceMessage",WellKnownObjectMode.SingleTon);

(2)SingleCall模式

　　注册对象的方法基本上和SingleTon模式相同，只需要将枚举参数WellKnownObjectMode改为SingleCall就可以了。

1 RemotingConfiguration.RegisterWellKnownServiceType(
2 typeof(ServerRemoteObject.ServerObject),
3 "ServiceMessage",WellKnownObjectMode.SingleCall);

(3)激活模式

　　对于客户端激活模式，使用的方法又有不同，但区别不大，看了代码就一目了然。

1 RemotingConfiguration.ApplicationName = "ServiceMessage";
2 RemotingConfiguration.RegisterActivatedServiceType(
3 typeof(ServerRemoteObject.ServerObject));

为什么要在注册对象方法前设置ApplicationName属性呢？其实这个属性就是该对象的URI。对于WellKnown模式，URI是放在RegisterWellKnownServiceType()方法的参数中，当然也可以拿出来专门对ApplicationName属性赋值。而RegisterActivatedServiceType()方法的重载中，没有ApplicationName的参数，所以必须分开。

3、注销通道

如果要关闭Remoting的服务，则需要注销通道，也可以关闭对通道的监听。在Remoting中当我们注册通道的时候，就自动开启了通道的监听。而如果关闭了对通道的监听，则该通道就无法接受客户端的请求，但通道仍然存在，如果你想再一次注册该通道，会抛出异常。

 1 //获得当前已注册的通道；
 2 IChannel[] channels = ChannelServices.RegisteredChannels;
 3 //关闭指定名为MyTcp的通道；
 4 foreach (IChannel eachChannel in channels)
 5 {
 6     if (eachChannel.ChannelName == "MyTcp")
 7     {
 8         TcpChannel tcpChannel = (TcpChannel)eachChannel;
 9         //关闭监听；
10         tcpChannel.StopListening(null);
11         //注销通道；
12         ChannelServices.UnregisterChannel(tcpChannel);
13     }
14 }

代码中，RegisterdChannel属性获得的是当前已注册的通道。在Remoting中，是允许同时注册多个通道的，这一点会在后面说明。

客户端

客户端主要做两件事，一是注册通道。这一点从通信框架图中就可以看出，Remoting中服务器端和客户端都必须通过通道来传递消息，以获得远程对象。第二步则是获得该远程对象。

1、注册通道：

1 TcpChannel channel = new TcpChannel();
2 ChannelServices.RegisterChannel(channel);

注意在客户端实例化通道时，是调用的默认构造函数，即没有传递端口号。事实上，这个端口号是缺一不可的，只不过它的指定被放在后面作为了Uri的一部分。

2、获得远程对象。

与服务器端相同，不同的激活模式决定了客户端的实现方式也将不同。不过这个区别仅仅是WellKnown激活模式和客户端激活模式之间的区别，而对于SingleTon和SingleCall模式，客户端的实现完全相同。

(1) WellKnown激活模式

　要获得服务器端的知名远程对象，可通过Activator进程的GetObject()方法来获得：

1 ServerRemoteObject.ServerObject serverObj = (ServerRemoteObject.ServerObject)Activator.GetObject(
2 typeof(ServerRemoteObject.ServerObject), "tcp://localhost:8080/ServiceMessage");

首先以WellKnown模式激活，客户端获得对象的方法是使用GetObject（）。

　　其中参数第一个是远程对象的类型

　　第二个参数就是服务器端的uri

如果是http通道，自然是用了。因为我是用本地机，所以这里是localhost，你可以用具体的服务器IP地址来代替它。端口必须和服务器端的端口一致。后面则是服务器定义的远程对象服务名，即ApplicationName属性的内容。

(2)客户端激活模式

　　如前所述，WellKnown模式在客户端创建对象时，只能调用默认的构造函数，上面的代码就说明了这一点，因为GetObject()方法不能传递构造函数的参数。而客户端激活模式则可以通过自定义的构造函数来创建远程对象。

客户端激活模式有两种方法：

　　1) 调用RemotingConfiguration的静态方法RegisterActivatedClientType()。这个方法返回值为Void，它只是将远程对象注册在客户端而已。具体的实例化还需要调用对象类的构造函数。

1 RemotingConfiguration.RegisterActivatedClientType(
2 typeof(ServerRemoteObject.ServerObject),
3 "tcp://localhost:8080/ServiceMessage");
1 ServerRemoteObject.ServerObject serverObj = new ServerRemoteObject.ServerObject();

　　

　　2) 调用进程Activator的CreateInstance()方法。这个方法将创建方法参数指定类型的类对象。它与前面的GetObject()不同的是，它要在客户端调用构造函数，而GetObject()只是获得对象，而创建实例是在服务器端完成的。CreateInstance()方法有很多个重载，我着重说一下其中常用的两个。

a、 public static object CreateInstance(Type type, object[] args, object[] activationAttributes);

参数说明：

　　type：要创建的对象的类型。

　　args ：与要调用构造函数的参数数量、顺序和类型匹配的参数数组。如果 args 为空数组或空引用（Visual Basic 中为 Nothing），则调用不带任何参数的构造函数（默认构造函数）。

数组。

　　这里的参数args是一个object[]数组类型。它可以传递要创建对象的构造函数中的参数。从这里其实可以得到一个结论：WellKnown激活模式所传递的远程对象类，只能使用默认的构造函数；而Activated模式则可以用户自定义构造函数。activationAttributes参数在这个方法中通常用来传递服务器的url。

假设我们的远程对象类ServerObject有个构造函数：

　

1 　ServerObject(string pName,string pSex,int pAge)
2 　　{
3 　　　　name = pName;
4 　　　　sex = pSex;
5 　　　　age = pAge;
6 　　}

那么实现的代码是：

1 object[] attrs = {new UrlAttribute("tcp://localhost:8080/ServiceMessage")};
2 object[] objs = new object[3];
3 objs[0] = "wayfarer";
4 objs[1] = "male";
5 objs[2] = 28;

1 ServerRemoteObject.ServerObject = Activator.CreateInstance( typeof(ServerRemoteObject.ServerObject),objs,attrs);

可以看到，objs[]数组传递的就是构造函数的参数。

b、public static ObjectHandle CreateInstance(string assemblyName, string typeName, object[] activationAttribute);

参数说明：

　　assemblyName ：将在其中查找名为 typeName 的类型的程序集的名称。如果 assemblyName 为空引用（Visual Basic 中为 Nothing），则搜索正在执行的程序集。

typeName：首选类型的名称。

activationAttributes ：包含一个或多个可以参与激活的属性的数组。

参数说明一目了然。注意这个方法返回值为ObjectHandle类型，因此代码与前不同：

1 object[] attrs = {new UrlAttribute("tcp://localhost:8080/EchoMessage")};
2 ObjectHandle handle = Activator.CreateInstance("ServerRemoteObject",
3 "ServerRemoteObject.ServerObject",attrs);
4 ServerRemoteObject.ServerObject obj = (ServerRemoteObject.ServerObject)handle.Unwrap();

这个方法实际上是调用的默认构造函数。ObjectHandle.Unwrap()方法是返回被包装的对象。

说明：要使用UrlAttribute，还需要在命名空间中添加：using System.Runtime.Remoting.Activation;

基础补充

通过上面的描述，基本上已经完成了一个最简单的Remoting程序。这是一个标准的创建Remoting程序的方法，但在实际开发过程中，我们遇到的情况也许千奇百怪，如果只掌握一种所谓的“标准”，就妄想可以“一招鲜、吃遍天”，是不可能的。

1、注册多个通道

　　在Remoting中，允许同时创建多个通道，即根据不同的端口创建不同的通道。但是，Remoting要求通道的名字必须不同，因为它要用来作为通道的唯一标识符。虽然IChannel有ChannelName属性，但这个属性是只读的。因此前面所述的创建通道的方法无法实现同时注册多个通道的要求。

这个时候，我们必须用到System.Collection中的IDictionary接口：

注册Tcp通道：

1 IDictionary tcpProp = new Hashtable();
2 tcpProp["name"] = "tcp9090";
3 tcpProp["port"] = 9090;
4 IChannel channel = new TcpChannel(tcpProp,
5 new BinaryClientFormatterSinkProvider(),
6 new BinaryServerFormatterSinkProvider());
7 ChannelServices.RegisterChannel(channel);

注册Http通道：

1 IDictionary httpProp = new Hashtable();
2 httpProp["name"] = "http8080";
3 httpProp["port"] = 8080;
4 IChannel channel = new HttpChannel(httpProp,
5 new SoapClientFormatterSinkProvider(),
6 new SoapServerFormatterSinkProvider());
7 ChannelServices.RegisterChannel(channel);

在name属性中，定义不同的通道名称就可以了。

2、远程对象元数据相关性

由于服务器端和客户端都要用到远程对象，通常的方式是生成两份完全相同的对象Dll，分别添加引用。不过为了代码的安全性，且降低客户端对远程对象元数据的相关性，我们有必要对这种方式进行改动。即在服务器端实现远程对象，而在客户端则删除这些实现的元数据。

由于激活模式的不同，在客户端创建对象的方法也不同，所以要分离元数据的相关性，也应分为两种情况。

(1) WellKnown激活模式：

　　通过接口来实现。在服务器端，提供接口和具体类的实现，而在客户端仅提供接口：

1 public interface IServerObject
2 {
3 　　Person GetPersonInfo(string name,string sex,int age);
4 }
1 public class ServerObject:MarshalByRefObject,IServerObject
2 { ......}

注意：两边生成该对象程序集的名字必须相同，严格地说，是命名空间的名字必须相同。

(2) 客户端激活模式：

　　如前所述，对于客户端激活模式，不管是使用静态方法，还是使用CreateInstance()方法，都必须在客户端调用构造函数实例化对象。所以，在客户端我们提供的远程对象，就不能只提供接口，而没有类的实现。实际上，要做到与远程对象元数据的分离，可以由两种方法供选择：

a、利用WellKnown激活模式模拟客户端激活模式：

方法是利用设计模式中的“抽象工厂”，下面的类图表描述了总体解决方案：

我们在服务器端的远程对象中加上抽象工厂的接口和实现类：

 1 public interface IServerObject
 2 {
 3 　　Person GetPersonInfo(string name,string sex,int age);
 4 }
 5 public interface IServerObjFactory
 6 {
 7 　　IServerObject CreateInstance();
 8 }
 9 public class ServerObject:MarshalByRefObject,IServerObject
10 {
11 　　public Person GetPersonInfo(string name,string sex,int age)
12 　　{
13 　　　　Person person = new Person();
14 　　　　person .Name = name;
15 　　　　person.Sex = sex;
16 　　　　person.Age = age;
17 　　　　return person;
18 　　}
19 }
20 public class ServerObjFactory:MarshalByRefObject,IServerObjFactory
21 {
22 　　public IServerObject CreateInstance()
23 　　{
24 　　　　return new ServerObject();
25 　　}
26 }

然后再客户端的远程对象中只提供工厂接口和原来的对象接口：

1 public interface IServerObject
2 {
3 　　Person GetPersonInfo(string name,string sex,int age);
4 }
5 public interface IServerObjFactory
6 {
7 　　IServerObject CreateInstance();
8 }

我们用WellKnown激活模式注册远程对象，在服务器端：

//传递对象；

1 RemotingConfiguration.RegisterWellKnownServiceType(
2 typeof(ServerRemoteObject.ServerObjFactory),
3 "ServiceMessage",WellKnownObjectMode.SingleCall);

注意这里注册的不是ServerObject类对象，而是ServerObjFactory类对象。

客户端：

1 ServerRemoteObject.IServerObjFactory serverFactory =
2 (ServerRemoteObject.IServerObjFactory) Activator.GetObject(
3 typeof(ServerRemoteObject.IServerObjFactory),
4 "tcp://localhost:8080/ServiceMessage");
5 ServerRemoteObject.IServerObject serverObj = serverFactory.CreateInstance();

为什么说这是一种客户端激活模式的模拟呢？从激活的方法来看，我们是使用了SingleCall模式来激活对象，但此时激活的并非我们要传递的远程对象，而是工厂对象。如果客户端要创建远程对象，还应该通过工厂对象的CreateInstance()方法来获得。而这个方法正是在客户端调用的。因此它的实现方式就等同于客户端激活模式。

b、利用替代类来取代远程对象的元数据

实际上，我们可以用一个trick，来欺骗Remoting。这里所说的替代类就是这个trick了。既然是提供服务，Remoting传递的远程对象其实现的细节当然是放在服务器端。而要在客户端放对象的副本，不过是因为客户端必须调用构造函数，而采取的无奈之举。既然具体的实现是在服务器端，又为了能在客户端实例化，那么在客户端就实现这些好了。至于实现的细节，就不用管了。

如果远程对象有方法，服务器端则提供方法实现，而客户端就提供这个方法就OK了，至于里面的实现，你可以是抛出一个异常，或者return 一个null值；如果方法返回void，那么里面可以是空。关键是这个客户端类对象要有这个方法。这个方法的实现，其实和方法的声明差不多，所以我说是一个trick。方法如是，构造函数也如此。

还是用代码来说明这种“阴谋”，更直观：

服务器端：

 1 public class ServerObject:MarshalByRefObject
 2 {
 3 　　public ServerObject()
 4 　　{
 5 　　}
 6 　　public Person GetPersonInfo(string name,string sex,int age)
 7 　　{
 8 　　　　Person person = new Person();
 9 　　　　person .Name = name;
10 　　　　person.Sex = sex;
11 　　　　person.Age = age;
12 　　　　return person;
13 　　}
14 }

客户端：

 1 public class ServerObject:MarshalByRefObject
 2 {
 3 　　public ServerObj()
 4 　　{
 5 　　　　throw new System.NotImplementedException();
 6 　　}
 7 　　public Person GetPersonInfo(string name,string sex,int age)
 8 　　{
 9 　　　　throw new System.NotImplementedException();
10 　　}
11 }

比较客户端和服务器端，客户端的方法GetPersonInfo()，没有具体的实现细节，只是抛出了一个异常。或者直接写上语句return null，照样OK。我们称客户端的这个类为远程对象的替代类。

3、利用配置文件实现

前面所述的方法，于服务器uri、端口、以及激活模式的设置是用代码来完成的。其实我们也可以用配置文件来设置。这样做有个好处，因为这个配置文件是Xml文档。如果需要改变端口或其他，我们就不需要修改程序，并重新编译，而是只需要改变这个配置文件即可。

(1) 服务器端的配置文件：

<configuration>

<system.runtime.remoting>

<application name="ServerRemoting">

<service>

<wellknown mode="Singleton" type="ServerRemoteObject.ServerObject" objectUri="ServiceMessage"/>

</service>

<channels>

<channel ref="tcp" port="8080"/>

</channels>

</application>

</system.runtime.remoting>

</configuration>

如果是客户端激活模式，则把wellknown改为activated，同时删除mode属性。

把该配置文件放到服务器程序的应用程序文件夹中，命名为ServerRemoting.config。那么前面的服务器端程序直接用这条语句即可：

RemotingConfiguration.Configure("ServerRemoting.config");

(2)客户端配置文件

如果是客户端激活模式，修改和上面一样。调用也是使用RemotingConfiguration.Configure()方法来调用存储在客户端的配置文件。

配置文件还可以放在machine.config中。如果客户端程序是web应用程序，则可以放在web.config中。

4、启动/关闭指定远程对象

Remoting中没有提供类似UnregisterWellKnownServiceType()的方法，也即是说，一旦通过注册了远程对象，如果没有关闭通道的话，该对象就一直存在于通道中。只要客户端激活该对象，就会创建对象实例。如果Remoting传送的只有一个远程对象，这不存在问题，关闭通道就可以了。如果传送多个远程对象呢？要关闭指定的远程对象应该怎么做？关闭之后又需要启动又该如何？

我们注意到在Remoting中提供了Marshal()和Disconnect()方法，答案就在这里。Marshal()方法是将MarshalByRefObject类对象转化为ObjRef类对象，这个对象是存储生成代理以与远程对象通讯所需的所有相关信息。这样就可以将该实例序列化以便在应用程序域之间以及通过网络进行传输，客户端就可以调用了。而Disconnect()方法则将具体的实例对象从通道中断开。

方法如下：

首先注册通道：

TcpChannel channel = new TcpChannel(8080);

ChannelServices.RegisterChannel(channel);

接着启动服务：

先在服务器端实例化远程对象。

ServerObject obj = new ServerObject();

然后，注册该对象。注意这里不用RemotingConfiguration.RegisterWellKnownServiceType()，而是使用RemotingServices.Marshal()：

ObjRef objrefWellKnown = RemotingServices.Marshal(obj, "ServiceMessage");

如果要注销对象，则：

RemotingServices.Disconnect(obj);

要注意，这里Disconnect的类对象必须是前面实例化的对象。正因为此，我们可以根据需要创建指定的远程对象，而关闭时，则Disconnect之前实例化的对象。

至于客户端的调用，和前面WellKnown模式的方法相同，仍然是通过Activator.GetObject()来获得。但从实现代码来看，我们会注意到一个问题，由于服务器端是显式的实例化了远程对象，因此不管客户端有多少，是否相同，它们调用的都是同一个远程对象。因此我们将这个方法称为模拟的SingleTon模式。

客户端激活模式

我们也可以通过Marshal()和Disconnect()来模拟客户端激活模式。首先我们来回顾“远程对象元数据相关性”一节，在这一节中，我说到采用设计模式的“抽象工厂”来创建对象实例，以此用SingleCall模式来模拟客户端激活模式。在仔细想想前面的模拟的SingleTon模式。是不是答案就将呼之欲出呢？

在“模拟的SingleTon”模式中，我们是将具体的远程对象实例进行Marshal，以此让客户端获得该对象的引用信息。那么我们换一种思路，当我们用抽象工厂提供接口，工厂类实现创建远程对象的方法。然后我们在服务器端创建工厂类实例。再将这个工厂类实例进行Marshal。而客户端获取对象时，不是获取具体的远程对象，而是获取具体的工厂类对象。然后再调用CreateInstance()方法来创建具体的远程对象实例。此时，对于多个客户端而言，调用的是同一个工厂类对象；然而远程对象是在各个客户端自己创建的，因此对于远程对象而言，则是由客户端激活，创建的是不同对象了。

当我们要启动/关闭指定对象时，只需要用Disconnet()方法来注销工厂类对象就可以了。

时间： 2024-10-12 19:07:32

.Net中Remoting通信机制的相关文章

.Net中Remoting通信机制简单实例

.Net中Remoting通信机制 前言: 本程序例子实现一个简单的Remoting通信案例 本程序采用语言:c# 编译工具:vs2013工程文件 编译环境:.net 4.0 程序模块: Test测试 Talker Server端 Client端 源代码工程文件下载 Test测试程序截图: Talker类: 1 public class Talker : MarshalByRefObject 2 { 3 public void Talk(string word) 4 { 5 System.Con

TensorFlow中的通信机制——Rendezvous（一）本地传输

背景 [作者:DeepLearningStack,阿里巴巴算法工程师,开源TensorFlow Contributor] 在TensorFlow源码中我们经常能看到一个奇怪的词--Rendezvous.如果从仔细统计该单词出现的频率和模块,你会发现无论在单机还是分布式,无论在core目录还是contrib目录都存在它的身影,所涉及的模块非常多.Rendezvous是一个法语单词,发音也比较特殊,一般直译为"约会.相会.会和",而在TensorFlow中,Rendezvous是用来完成消

Android中的常见通信机制和Linux中的通信机制

Handler Handler是Android系统中的一种消息传递机制,起作用是应对多线程场景.将A进程的消息传递给B线程,实现异步消息处理.很多情况是将工作线程中需要更新UI的操作消息传递给UI主线程,而实现更新UI操作. 因为工作线程和主线程是共享地址空间,即Handler实例对象mHandler位于线程间共享的内存堆上,工作线程和主线程直接使用该对象,只需要注意多线程的同步问题.工作系统通过mHandler向其成员变量MessageQueue中添加Message,而主线程一直处于loop中

TensorFlow中的通信机制——Rendezvous（二）gRPC传输

背景 [作者:DeepLearningStack,阿里巴巴算法工程师,开源TensorFlow Contributor] 本篇是TensorFlow通信机制系列的第二篇文章,主要梳理使用gRPC网络传输部分模块的结构和源码.如果读者对TensorFlow中Rendezvous部分的基本结构和原理还不是非常了解,那么建议先从这篇文章开始阅读.TensorFlow在最初被开源时还只是个单机的异构训练框架,在迭代到0.8版本开始正式支持多机分布式训练.与其他分布式训练框架不同,Google选用了开源项

Android中AIDL通信机制分析

一.背景 ·1.AIDL出现的原因 在android系统中,每一个程序都是运行在自己的进程中,进程之间无法进行通讯,为了在Android平台,一个进程通常不能访问另一个进程的内存空间,所以要想对话,需要将对象分解成操作系统可以理解的基本单元,并且有序的通过进程边界.通过代码来实现这个数据传输过程是冗长乏味的,Android提供了AIDL工具来处理这项工作,实现IPC(进行间的通信)与J2e中的RMI类似. ·2.绑定service 我看了很多人都博客都没有说到这里,其实我个人感觉AIDL就是一个

Android中对消息机制(Handler)的再次解读

今天遇到一些关于在子线程中操作Handler的问题,感觉又要研究源代码了,但是关于Handler的话,我之前研究过,可以参考这篇文章:http://blog.csdn.net/jiangwei0910410003/article/details/17021809.但是这篇文章没有说的那么深入了,所以这次就更深入的解读一下. 摘要 Android中的应用程序都是通过消息驱动的,系统为每一个应用程序维护一个消息队列(MessageQueue),应用程序的主线程不断的从这个消息队列中获取消息(Loop

flux沉思录：面向store和通信机制的前端框架

一.综述 Flux 被用来描述“单向”的数据流,且包含某些特殊的事件和监听器. 响应式编程是一种面向数据流和变化传播的编程范式 flux是响应式编程的一种? Flux 在本质上采用了模型-视图-控制器 (MVC) 的结构,但引入了很高的复杂性. https://www.ibm.com/developerworks/cn/web/wa-manage-state-with-redux-p1-david-geary/?mhq=使用%20Redux%20管理状态 二.store与model: store

linux套接字通信之recv中的缓存机制的研究

以前一直有这么一个小小的疑惑,当一个进程注册一个套接字后,如果这个套接字没有被调用recv函数接受数据包,那么这个套接字能接受到数据包吗? 或者这样说,如果我的程序注册了一个套接字去接受数据包,但是每收到一个数据包都需要很长一段时间处理,并且在处理数据包的途中recv函数使没有被调用的,那么如果程序再处理数据包的途中有数据包到来,那我的程序会不会漏过这些数据包(那个包到达的时候程序在处理别的包,而没有调用recv函数)? 答案是不会的.事实上linux中会为每个套接字建立缓存,当属于套接字的包到

（3）MEF插件系统中通信机制的设计和实现

1.背景 一般的WinForm中通过C#自带的Event机制便能很好的实现事件的注册和分发,但是,在插件系统中却不能这么简单的直接用已有的类来完成.一个插件本不包含另外一个插件,它们均是独立解耦的,实现插件和插件间的通信还需要我们设计出一个事件引擎来完成这个需求. 目前很多高级语言中基本都实现了观察者模式,并进行了自己的包装.比如C#中的delegate和event组合,java awt中的Event和addActionListener组合,Flex中的Event.addEventListene