Microsoft .Net Remoting系列教程之一:.Net Remoting基础篇

一、remoting基础

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

　　在remoting中是通过通道（channel）来实现两个应用程序域之间对象的通信的。如图所示：

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

　　在remoting中，对于要传递的对象，设计者除了需要了解通道的类型和端口号之外，无需再了解数据包的格式。但必须注意的是，客户端在获取服务器端对象时，并不是获得实际的服务端对象，而是获得它的引用。这既保证了客户端和服务器端有关对象的松散耦合，同时也优化了通信的性能。

1、remoting的两种通道

　　remoting的通道主要有两种：tcp和http。在.net中，system.runtime.remoting.channel中定义了ichannel接口。ichannel接口包括了tcpchannel通道类型和http通道类型。它们分别对应remoting通道的这两种类型。

　　tcpchannel类型放在名字空间system.runtime.remoting.channel.tcp中。tcp通道提供了基于socket的传输工具，使用tcp协议来跨越remoting边界传输序列化的消息流。tcpchannel类型默认使用二进制格式序列化消息对象，因此它具有更高的传输性能。httpchannel类型放在名字空间system.runtime.remoting.channel.http中。它提供了一种使用http协议，使其能在internet上穿越防火墙传输序列化消息流。默认情况下，httpchannel类型使用soap格式序列化消息对象，因此它具有更好的互操作性。通常在局域网内，我们更多地使用tcpchannel；如果要穿越防火墙，则使用httpchannel。

2、远程对象的激活方式

　　在访问远程类型的一个对象实例之前，必须通过一个名为activation的进程创建它并进行初始化。这种客户端通过通道来创建远程对象，称为对象的激活。在remoting中，远程对象的激活分为两大类：服务器端激活和客户端激活。

　　(1) 服务器端激活，又叫做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状态。

　　(2) 客户端激活。与wellknown模式不同，remoting在激活每个对象实例的时候，会给每个客户端激活的类型指派一个uri。客户端激活模式一旦获得客户端的请求，将为每一个客户端都建立一个实例引用。singlecall模式和客户端激活模式是有区别的：首先，对象实例创建的时间不一样。客户端激活方式是客户一旦发出调用的请求，就实例化；而singlecall则是要等到调用对象方法时再创建。其次，singlecall模式激活的对象是无状态的，对象生命期的管理是由gc管理的，而客户端激活的对象则有状态，其生命周期可自定义。其三，两种激活模式在服务器端和客户端实现的方法不一样。尤其是在客户端，singlecall模式是由getobject()来激活，它调用对象默认的构造函数。而客户端激活模式，则通过createinstance()来激活，它可以传递参数，所以可以调用自定义的构造函数来创建实例。

二、远程对象的定义

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

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

以下是一个远程对象类的定义：

public class serverobject:marshalbyrefobject
{
 public person getpersoninfo(string name,string sex,int age)
 {
 person person = new person();
 person.name = name;
 person.sex = sex;
 person.age = age;
 return person;
 }
}

　　这个类只实现了最简单的方法，就是设置一个人的基本信息，并返回一个person类对象。注意这里返回的person类。由于这里所传递的person则是以传值的方式来完成的，而remoting要求必须是引用的对象，所以必须将person类序列化。

　　因此，在remoting中的远程对象中，如果还要调用或传递某个对象，例如类，或者结构，则该类或结构则必须实现串行化

attribute[serializableattribute]：
[serializable]
public class person
{
 public person()
 {
 
 }

 private string name;
 private string sex;
 private int age;

 public string name
 {
 get {return name;}
 set {name = value;}
 }

 public string sex
 {
 get {return sex;}
 set {sex = value;}
 }

 public int age
 {
 get {return age;}
 set {age = value;}
 }
}

　　将该远程对象以类库的方式编译成dll。这个dll将分别放在服务器端和客户端，以添加引用。

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

三、服务器端

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

1、注册通道

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

　　注册tcpchannel，首先要在项目中添加引用“system.runtime.remoting”，然后using名字空间：system.runtime.remoting.channel.tcp。代码如下：

tcpchannel channel = new tcpchannel(8080);
channelservices.registerchannel(channel);

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

2、注册远程对象

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

(1) singleton模式

对于wellknown对象，可以通过静态方法remotingconfiguration.registerwellknownservicetype()来实现：

remotingconfiguration.registerwellknownservicetype(
 typeof(serverremoteobject.serverobject),
 "servicemessage",wellknownobjectmode.singleton);

(2)singlecall模式

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

remotingconfiguration.registerwellknownservicetype(
 typeof(serverremoteobject.serverobject),
 "servicemessage",wellknownobjectmode.singlecall);

(3)客户端激活模式

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

remotingconfiguration.applicationname = "servicemessage";
remotingconfiguration.registeractivatedservicetype(
 typeof(serverremoteobject.serverobject));

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

3、注销通道

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

//获得当前已注册的通道；
ichannel[] channels = channelservices.registeredchannels;

//关闭指定名为mytcp的通道；
foreach (ichannel eachchannel in channels)
{
 if (eachchannel.channelname == "mytcp")
 {
 tcpchannel tcpchannel = (tcpchannel)eachchannel;

 //关闭监听；
 tcpchannel.stoplistening(null);

 //注销通道；
 channelservices.unregisterchannel(tcpchannel);
 }
}

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

四、客户端

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

1、注册通道：

tcpchannel channel = new tcpchannel();
channelservices.registerchannel(channel);

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

2、获得远程对象。

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

(1) wellknown激活模式

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

serverremoteobject.serverobject serverobj = (serverremoteobject.serverobject)activator.getobject(
 typeof(serverremoteobject.serverobject), "tcp://localhost:8080/servicemessage");

　　首先以wellknown模式激活，客户端获得对象的方法是使用getobject（）。其中参数第一个是远程对象的类型。第二个参数就是服务器端的uri。如果是http通道，自然是用http://localhost:8080/servicemessage了。因为我是用本地机，所以这里是localhost，你可以用具体的服务器ip地址来代替它。端口必须和服务器端的端口一致。后面则是服务器定义的远程对象服务名，即applicationname属性的内容。

(2) 客户端激活模式

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

客户端激活模式有两种方法：
1) 调用remotingconfiguration的静态方法registeractivatedclienttype()。这个方法返回值为void，它只是将远程对象注册在客户端而已。具体的实例化还需要调用对象类的构造函数。

remotingconfiguration.registeractivatedclienttype(    
 typeof(serverremoteobject.serverobject),
 "tcp://localhost:8080/servicemessage");
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），则调用不带任何参数的构造函数（默认构造函数）。
activationattributes ：包含一个或多个可以参与激活的属性的数组。

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

serverobject(string pname,string psex,int page)
{
 name = pname;
 sex = psex;
 age = page;
}

那么实现的代码是：

object[] attrs = {new urlattribute("tcp://localhost:8080/servicemessage")};
object[] objs = new object[3];
objs[0] = "wayfarer";
objs[1] = "male";
objs[2] = 28;
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类型，因此代码与前不同：

object[] attrs = {new urlattribute("tcp://localhost:8080/echomessage")};   
objecthandle handle = activator.createinstance("serverremoteobject",
 "serverremoteobject.serverobject",attrs);
serverremoteobject.serverobject obj = (serverremoteobject.serverobject)handle.unwrap();

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

说明：要使用urlattribute，还需要在命名空间中添加：using system.runtime.remoting.activation;

五、remoting基础的补充

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

1、注册多个通道

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

这个时候，我们必须用到system.collection中的idictionary接口：

注册tcp通道：

idictionary tcpprop = new hashtable();
tcpprop["name"] = "tcp9090";
tcpprop["port"] = 9090;
ichannel channel = new tcpchannel(tcpprop,
 new binaryclientformattersinkprovider(),
 new binaryserverformattersinkprovider());
channelservices.registerchannel(channel);

注册http通道：

idictionary httpprop = new hashtable();
httpprop["name"] = "http8080";
httpprop["port"] = 8080;
ichannel channel = new httpchannel(httpprop,
 new soapclientformattersinkprovider(),
 new soapserverformattersinkprovider());
channelservices.registerchannel(channel);

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

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

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

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

(1) wellknown激活模式：

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

public interface iserverobject
{
 person getpersoninfo(string name,string sex,int age);
}

public class serverobject:marshalbyrefobject,iserverobject
{ ......}

注意：两边生成该对象程序集的名字必须相同，严格地说，是命名空间的名字必须相同。
          
(2) 客户端激活模式：

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

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

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

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

public interface iserverobject
{
 person getpersoninfo(string name,string sex,int age);
}

public interface iserverobjfactory
{
 iserverobject createinstance();  
}

public class serverobject:marshalbyrefobject,iserverobject
{
 public person getpersoninfo(string name,string sex,int age)
 {
  person person = new person();
  person.name = name;
  person.sex = sex;
  person.age = age;
  return person;
 }  
}

public class serverobjfactory:marshalbyrefobject,iserverobjfactory
{
 public iserverobject createinstance()
 {
  return new serverobject();
 }
}

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

public interface iserverobject
{
 person getpersoninfo(string name,string sex,int age);
}

public interface iserverobjfactory
{
 iserverobject createinstance();  
}

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

//传递对象；
remotingconfiguration.registerwellknownservicetype(
 typeof(serverremoteobject.serverobjfactory),
 "servicemessage",wellknownobjectmode.singlecall);

注意这里注册的不是serverobject类对象，而是serverobjfactory类对象。

客户端：

serverremoteobject.iserverobjfactory serverfactory =    
 (serverremoteobject.iserverobjfactory) activator.getobject(
 typeof(serverremoteobject.iserverobjfactory),
 "tcp://localhost:8080/servicemessage");

serverremoteobject.iserverobject serverobj = serverfactory.createinstance();

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

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

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

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

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

服务器端：

public class serverobject:marshalbyrefobject
{
 public serverobject()
 {
  
 }

 public person getpersoninfo(string name,string sex,int age)
 {
  person person = new person();
  person.name = name;
  person.sex = sex;
  person.age = age;
  return person;
 }  
}

客户端：

public class serverobject:marshalbyrefobject
{
 public serverobj()
 {
  throw new system.notimplementedexception();
 }

 public person getpersoninfo(string name,string sex,int age)
 {
  throw new system.notimplementedexception();
 }  
}

　　比较客户端和服务器端，客户端的方法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()方法来注销工厂类对象就可以了。

六、小结

　　microsoft.net remoting真可以说是博大精深。整个remoting的内容不是我这一篇小文所能尽述的，更不是我这个remoting的初学者所能掌握的。王国维在《人间词话》一书中写到：古今之成大事业大学问者，必经过三种境界。“昨夜西风凋碧树，独上高楼，望尽天涯路。”此第一境界也。“衣带渐宽终不悔，为伊消得人憔悴。”此第二境界也。“众里寻他千百度，蓦然回首，那人却在灯火阑珊处。”此第三境界也。如以此来形容我对remoting的学习，还处于“独上高楼，望尽天涯路”的时候，真可以说还未曾登堂入室。

　　或许需得“衣带渐宽”，学得remoting“终不悔”，方才可以“蓦然回首”吧。

　　以上就是.net remoting基础的全部内容，希望能给大家一个参考，也希望大家多多支持。