读《.Net 之美》解析.Net Remoting （应用程序域）-- Part.1

浏览数：36 / 时间：2015年06月09日

读《.Net 之美》解析.Net Remoting （应用程序域）-Part1

理解 .Net Remoting

前言：

看张子阳老师的文章，总是给自己很大的信心，这个专题基本上以张老师的书为主，我整理书中的主要代码，补充了些自己的理解,希望和大家一起学习：）

背景：

分布式开发是一个重要的方向，前段时间做公司的一个爬虫项目，多个客户端和服务端的交互，使我产生了浓厚的兴趣，WCF、WebService、Socket也是常用的技术。.Net Remoting 在.NetFrameWork 3.5前是很热的技术，这一章由（1）应用程序域。（2）传值封送（Marshal by value）（3）传引用封送（Marshal by reference）（4）远程方法回调（5）客户端和服务端的综合应用

基本概念：

应用程序域（Application Domain）,域的概念是一个范围，一个中介，既能为程序集（.net 的可执行程序集 .exe）提供托管环境，又能运行在非托管的操作系统进程之内，这个中介就是应用程序域概念的简单阐述。所有的.NET 程序集都运行在应用程序域中。

如果将一个应用程序域视为一个轻量级进程，在一个操作系统进程中可以包含多个，那这个进程有哪些特性呢？默认应用程序域和隔离性是两个重要的概念。

(1)先加载完可执行程序集->.NET 在当前进程中创建唯一且新的应用程序域，称之为默认应用程序域。

(2)一个进程中包含多个应用程序域，彼此相互独立。

综上所述及推理：

不同的应用程序域可以位于同一进程、同一计算机的不同进程、网络上两台不同计算机的进程中。在不同的应用程序域中是不是有我们关注的对象，对象之间如何交换数据，堆上的内容怎么访问，引出了我们的主角.Net Remoting.

基本操作：

.NET 中，将应用程序域封装为System.AppDomain,这个类提供了和应用程序域有关的操作，离不开加载和创建的基本方法,下面的示例代码我们有个了解，在之后实际代码中，会引用就可以了。之后在张老师书中的实例代码，我在调试后，会把整个解决方案打包上传，希望大家批评指正。

//获取当前应用程序域
  //Fun1
            AppDomain currentDomain = AppDomain.CurrentDomain;
  //Fun2
           AppDomain currentDomain2 = Thread.GetDomain();

//获取应用程序域的名称
 currentDomain.FriendlyName;

//创建新的应用程序域
AppDomain newDomain = AppDomain.CreateDomain("NewDomain");

//应用程序域中创建对象
  //Fun1
DemoClass obj=(DemoClass)newDomain.CreateInstanceAndUnwrap("ClassLib", "ClassLib.DemoClass");
  //Fun2

1.1 在默认应用程序域中创建对象：大家可以思考下，我们一般用new DemoClass（）的方式和在应用程序域中创建有什么异同或优势，是访问更便捷还是更优化?

 1 //类库
 2   public class DemoClass
 3     {
 4        private int count = 0;
 5        public DemoClass()
 6        {
 7            Console.WriteLine("\n----DemoClass Constructor----");
 8        }
 9 
10        public void ShowCount(string name)
11        {
12            count++;
13            Console.WriteLine("{0},the count is {1}.",name,count);
14        }
15        
16         /// <summary>
17        /// 打印对象所在的应用程序域
18         /// </summary>
19        public void ShowAppDomain() {
20            AppDomain currentDomain = AppDomain.CurrentDomain;//获取代码所在的应用程序域
21            Console.WriteLine(currentDomain.FriendlyName);//获取应用程序域的名称
22        }
23 
24     }

 1 /*控制台测试默认应用程序域中创建对象*/    
 2 class Program
 3     {
 4         static void Main(string[] args)
 5         {
 6             Test1();
 7             //Test2();
 8         }
 9         
10         /// <summary>
11         /// 在当前AppDomain 中创建一个对象
12         /// </summary>
13         static void Test1() { 
14             //获取当前应用程序域-Fun1
15             AppDomain currentDomain = AppDomain.CurrentDomain;
16             //获取当前应用程序域-Fun2
17             AppDomain currentDomain2 = Thread.GetDomain();
18 
19             //显示名称
20             Console.WriteLine(currentDomain.FriendlyName);
21 
22             //准备创建对象
23             DemoClass obj;
24             //常规创建对象的方式-1
25             //obj = new DemoClass();
26 
27             //在默认应用程序域创建对象-2:方式1和2的结果相同。
28             obj = (DemoClass)currentDomain.CreateInstanceAndUnwrap("ClassLib", "ClassLib.DemoClass");//强制转换是否改变栈?
29 
30       obj.ShowAppDomain();
31             obj.ShowCount("Jimmy");
32             obj.ShowCount("Jimmy");
33 
34             Console.Read();
35         }
36 }

运行这段代码，得到的运行结果是

技术分享

1.2 在新建的应用程序域中创建对象

 1         /// <summary>
 2         /// 在新的应用程序域中创建对象
 3         /// </summary>
 4         static void Test2() {
 5             AppDomain currentDomain = AppDomain.CurrentDomain;
 6             Console.WriteLine(currentDomain.FriendlyName);
 7      
 8             //创建一个新的应用程序域,这里是关键代码
 9             AppDomain newDomain = AppDomain.CreateDomain("NewDomain");
10 
11             DemoClass obj;//当前默认应用程序域中开辟的栈空间。
12             //在新的应用程序域中创建对象:程序集“ClassLib, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null”中的类型“ClassLib.DemoClass”未标记为可序列化。
13             obj=(DemoClass)newDomain.CreateInstanceAndUnwrap("ClassLib", "ClassLib.DemoClass"); //新的应用程序域中创建的对象，本地进行反序列化（默认？），还原对象。
14             obj.ShowAppDomain();
15             obj.ShowCount("Jimmy");
16             obj.ShowCount("Jimmy");
17 
18             Console.Read();
19         }

在运行代码后，出现异常，在新的应用程序域中创建对象未标记可序列化，我们分析后，思考

AppDomain.CreateDomain("NewDomain");这句代码之后的对象，是在默认应用程序域还是新的程序域中创建，如果是新的应用程序域，怎么跨程序域取到堆中存储的内容，可序列化的标记是一个什么东东，标记后产生了那些作用。

在思考的同时，先解决问题，看能否得到我们想要的结果

 1     /// <summary>
 2     /// 标记为可序列化，对象从另一个应用程序域中（远程）传递到本地应用程序域。
 3     /// </summary>
 4     [Serializable]
 5     public class DemoClass
 6     {
 7        private int count = 0;
 8        public DemoClass()
 9        {
10            Console.WriteLine("\n----DemoClass Constructor----");
11        }
12 
13        public void ShowCount(string name)
14        {
15            count++;
16            Console.WriteLine("{0},the count is {1}.",name,count);
17        }
18        
19         /// <summary>
20        /// 打印对象所在的应用程序域
21         /// </summary>
22        public void ShowAppDomain() {
23            AppDomain currentDomain = AppDomain.CurrentDomain;//获取代码所在的应用程序域
24            Console.WriteLine(currentDomain.FriendlyName);//获取应用程序域的名称
25        }
26 
27     }

运行这段代码，得到的运行结果是：



我们在来还原一下问题，

currentDomain.FriendlyName//应用程序域的名称：ConsoleApp.vshost.exe，

在[Serializable]后发生了作用，可见新的引用程序域中的对象在默认应用程序域中可以"访问"到，这个过程不难想到：
先在远程创建对象（非本地默认应用程序域）->将对象序列化*->传递对象*->在本地进行反序列化（这个过程好像是透明的），最后还原成对象（在本地默认应用程序域中）,这里的传递过程包含着一些还没有提到的概念，我先标注了*。

我们学到这里好像还是没有体会到
DemoClass obj=new DemoClass（） 的方式和在应用程序域中创建的方法

DemoClass obj=(DemoClass)newDomain.CreateInstanceAndUnwrap("ClassLib", "ClassLib.DemoClass");

有什么异同或优势，是访问更便捷还是更优化，带着问题我们去了解下代理和封送...

1.3 代理和封送
1.3.1 代理
创建对象过程： 
1.new DemoClass(),在托管堆上创建一个对象，并且由obj 变量直接引用。

2.(DemoClass)newDomain.CreateInstanceAndUnwrap("ClassLib", "ClassLib.DemoClass"),实际上创建了两个对象，
先在NewDomain中第一次创建对象->然后将对象进行复制,序列化->之后进行封送（Marshaling）->接着在默认当前应用程序域（ConsoleApp.exe 客户端）,重新创建对象，并还原对象状态，创建对象代理（Proxy).
=>我们观察到当代理调用ShowDomain()时，显示的是 ConsoleApp.exe,是因为代理访问的是本地重新创建的对象而非远程对象。

代理这个名词是我联想到生活中的代办公司，我想去申请一家企业营业执照和其他,如果自己去办面临时间和沟通的成本，代办公司经常和政府办事人员打交道，只要我准备好需要的材料和支付必须的费用后，就静候佳音了。

回到项目中， 对于我（相当于客户端），和政府办事部门（想到于服务端）之间要沟通，需要代理帮忙，代理提供和远程对象（本例中是newDomain 中创建的DemoClass）完全相同的接口（此处的接口是指一个类型对外公开的部分，例如属性、方法和事件等）.NET 需要在客户端（本例中是ConsoleApp.exe）基于远程对象的类型元数据（Type Metadata）来创建代理，因此客户端必须包含远程对象的类型元数据，元数据简单说类型的名称、公共属性的名称、方法的签名和名称，不包括代码的实现。

封送（Marshal）：送有传递的意思，封理解成信息封装。
回到项目中,创建好的代理就像是远程对象一样,但代码中不包括方法体,代理仅仅是将自己与某一实际对象绑定，然后把客户程序对自己的请求打包成消息（Message)，随后发生给实际对象,请求发送给实际对象的过程,叫做封送（Marshal）.

代理的好处：对于客户端来说,远程的服务端对象就好像是在本地一样;
          对于服务端(远程的服务端对象)来说,就好像是为器本地对象提供服务。

1.3.2 传值封送、传引用封送

先放示意图给大家


传值封送


传引用封送(客户端激活对象的方式)




传值封送：位于ConsoleApp.exe 的Obj引用NewDomain 中创建对象时，.NET将NewDomain中对象的状态进行复制，序列化，然后在ConsoleApp.exe中重新创建对象，还原状态,并通过代理进行对对象进行访问.这种跨应用程序域的访问方式叫做传值封送（Mashal by value），有点类似于C#中参数的按值传递。

传引用封送： 传值封送在遇到大对象是效率会降低， 有一种让对象仍然保留在NewDomain,而在客户端创建代理，通过代理来访问远程对象,代理的接口和远程对象相同，当客户端在代理调用方法时:由代理将方法的请求返回给远程对象->远程对象执行方法的请求，最后将结果传给客户端的方式叫做传引用方式(Marshal by reference).

按引用封送的代码示例(一)：

 1 //类库  
 2 
 3  public class DemoClass1:MarshalByRefObject
 4     {
 5         private int count = 0;
 6         public DemoClass1()
 7         {
 8             Console.WriteLine("\n----DemoClass Constructor----");
 9         }
10 
11         public void ShowCount(string name)
12         {
13             count++;
14             Console.WriteLine("{0},the count is {1}.", name, count);
15         }
16         //打印对象所在的应用程序域
17         public void ShowAppDomain()
18         {
19             AppDomain currentDomain = AppDomain.CurrentDomain;//获取代码所在的应用程序域
20             Console.WriteLine(currentDomain.FriendlyName);//获取应用程序域的名称
21         }
22 
23     }

 1 //控制台应用程序      
 2   static void Main(string[] args)
 3         {
 4             Test2();
 5             //Test3();
 6         }
 7 
 8         /// <summary>
 9         /// 在新的应用程序域中创建对象
10         /// </summary>
11         static void Test2()
12         {
13             AppDomain currentDomain = AppDomain.CurrentDomain;
14             Console.WriteLine(currentDomain.FriendlyName);
15 
16             //创建一个新的应用程序域
17             AppDomain newDomain = AppDomain.CreateDomain("NewDomain");
18 
19             DemoClass1 obj;//当前默认应用程序域中开辟的栈空间,注意这里的位置
20             //在新的应用程序域中创建对象:程序集“ClassLib, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null”中的类型“ClassLib.DemoClass”未标记为可序列化。
21             obj = (DemoClass1)newDomain.CreateInstanceAndUnwrap("ClassLib1", "ClassLib1.DemoClass1"); //新的应用程序域中创建的对象，本地进行反序列化（默认？），还原对象。
22             obj.ShowAppDomain();
23             obj.ShowCount("Jimmy");
24             obj.ShowCount("Jimmy");//基于引用传递时，对象的状态是保留的,count的值基于变化
25             Console.Read();
26         }

运行这段代码，得到的运行结果是：

从结果中分析：有两点值得注意,

（1）obj.ShowAppDomain()//显示NewDomain,说明DemoClass类型实例obj没有传值封送到ConsoleApp.exe,而依然保留在NewDomain中，这个和MarshalByRefObject
标记有关,细心的朋友发现此时[Serializable]标记取消了,标记为[Serializable]仅仅说明可以被序列化，而标记上MarshalByRefObject后,它就永远不离开自己的应用程序域,以传引用的方式进行.
(2)对象状态保留,连续两次调用ShowCount()方法时，计数器count是累加的.
此时我们稍微修改代码，多创建一个DemoClass的实例，继续观察结果...

按引用封送的代码示例(二)：

 1         /// <summary>
 2         /// 在新的应用程序域中,创建两次对象
 3         /// </summary>
 4         static void Test3()
 5         {
 6             AppDomain currentDomain = Thread.GetDomain();//AppDomain.CurrentDomain;
 7             Console.WriteLine(currentDomain.FriendlyName);
 8           
 9             // create a new appdomain class.
10             AppDomain newDomain = AppDomain.CreateDomain("NewDomain");
11 
12             DemoClass1 obj, obj2;
13       
14             //在新的应用程序域中创建对象
15             obj=(DemoClass1)newDomain.CreateInstanceAndUnwrap("ClassLib1", "ClassLib1.DemoClass1");
16             obj.ShowAppDomain();
17             obj.ShowCount("Jimmy");
18             obj.ShowCount("Jimmy");
19             //Console.Read();
20 
21             obj2 = (DemoClass1)newDomain.CreateInstanceAndUnwrap("ClassLib1", "ClassLib1.DemoClass1");
22             obj2.ShowAppDomain();
23             obj2.ShowCount("Zhang");
24             obj2.ShowCount("Zhang");
25             Console.Read();
26         }

运行这段代码，得到的运行结果是：

技术分享

分析结果：在NewDomain 中分别创建了两个对象obj1和obj2为客户端服务,且这两个对象各创建了一次的方式(因为只调用一次构造函数),称为客户端激活对象(Client Actived Object,简称CAO).

总结:

通过以上概念和代码的解释，我们渐渐对Remoting有了初步的认识,把握住范围和对象两个关键概念。
1.范围：不管两个应用程序域位于同一进程,不同进程,还是不同计算机,只要是跨应用程序域的访问,都属于Remoting的范畴.
2.对象：
2.1 从请求和提供服务来分为客户端(发出请求)和服务端（提供服务类型）.
2.2 从应用程序域的角度来看,服务端的应用程序域仅仅是提供了一个服务类型的运行环境，所以本章将Remoting分为三部分.
2.2.1 服务端应用程序,提供了服务程序集的运行环境,可以是控制台,窗体,Window服务,IIS的工作者进程.服务程序集对象所在的应用程序域，也称为宿主应用程序域(Host AppDomain).
2.2.2 客户端应用程序域(Client AppDomain),向宿主应用程序域发出请求的程序域.
2.2.3 服务程序集,其中包含了提供服务的类型,这些类型常继承自MarshalByRefObject,从这句代码中分析obj = (DemoClass1)newDomain.CreateInstanceAndUnwrap("ClassLib1", "ClassLib1.DemoClass1");//DemoClass1所在的ClassLib1程序集.

项目结构：
项目环境：	VS2012+控制台应用程序	.Net Framework4.0
网盘路径：	http://pan.baidu.com/s/1kTJxBD1	随着文章更新代码

 
                                       感谢张老师的用心汇聚成的.NET之美，我们相逢于首图的二楼，一路走来，代码的光辉在闪闪发光。
                                       本文的链接参考：http://www.cnblogs.com/JimmyZhang/archive/2008/07/26/1252183.html
                                       书中的代码如果在调试中出现问题，欢迎大家指正，我再来修改，期待 ing...