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

 

读 《.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（） 的方式和在应用程序域中创建有什么异同或优势，是访问更便捷还是更优化?

//类库
  public class DemoClass
    {
       private int count = 0;
       public DemoClass()
       {
           Console.WriteLine("
----DemoClass Constructor----");
       }

       public void ShowCount(string name)
       {
           count++;
           Console.WriteLine("{0},the count is {1}.",name,count);
       }
       
        /// <summary>
       /// 打印对象所在的应用程序域
        /// </summary>
       public void ShowAppDomain() {
           AppDomain currentDomain = AppDomain.CurrentDomain;//获取代码所在的应用程序域
           Console.WriteLine(currentDomain.FriendlyName);//获取应用程序域的名称
       }

    }

 

/*控制台测试默认应用程序域中创建对象*/    
class Program
    {
        static void Main(string[] args)
        {
            Test1();
            //Test2();
        }
        
        /// <summary>
        /// 在当前AppDomain 中创建一个对象
        /// </summary>
        static void Test1() { 
            //获取当前应用程序域-Fun1
            AppDomain currentDomain = AppDomain.CurrentDomain;
            //获取当前应用程序域-Fun2
            AppDomain currentDomain2 = Thread.GetDomain();

            //显示名称
            Console.WriteLine(currentDomain.FriendlyName);

            //准备创建对象
            DemoClass obj;
            //常规创建对象的方式-1
            //obj = new DemoClass();

            //在默认应用程序域创建对象-2:方式1和2的结果相同。
            obj = (DemoClass)currentDomain.CreateInstanceAndUnwrap("ClassLib", "ClassLib.DemoClass");//强制转换是否改变栈?

      obj.ShowAppDomain();
            obj.ShowCount("Jimmy");
            obj.ShowCount("Jimmy");

            Console.Read();
        }
}

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

 

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

        /// <summary>
        /// 在新的应用程序域中创建对象
        /// </summary>
        static void Test2() {
            AppDomain currentDomain = AppDomain.CurrentDomain;
            Console.WriteLine(currentDomain.FriendlyName);
     
            //创建一个新的应用程序域,这里是关键代码
            AppDomain newDomain = AppDomain.CreateDomain("NewDomain");

            DemoClass obj;//当前默认应用程序域中开辟的栈空间。
            //在新的应用程序域中创建对象:程序集“ClassLib, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null”中的类型“ClassLib.DemoClass”未标记为可序列化。
            obj=(DemoClass)newDomain.CreateInstanceAndUnwrap("ClassLib", "ClassLib.DemoClass"); //新的应用程序域中创建的对象，本地进行反序列化（默认？），还原对象。
            obj.ShowAppDomain();
            obj.ShowCount("Jimmy");
            obj.ShowCount("Jimmy");

            Console.Read();
        } 

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

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

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

 

    /// <summary>
    /// 标记为可序列化，对象从另一个应用程序域中（远程）传递到本地应用程序域。
    /// </summary>
    [Serializable]
    public class DemoClass
    {
       private int count = 0;
       public DemoClass()
       {
           Console.WriteLine("
----DemoClass Constructor----");
       }

       public void ShowCount(string name)
       {
           count++;
           Console.WriteLine("{0},the count is {1}.",name,count);
       }
       
        /// <summary>
       /// 打印对象所在的应用程序域
        /// </summary>
       public void ShowAppDomain() {
           AppDomain currentDomain = AppDomain.CurrentDomain;//获取代码所在的应用程序域
           Console.WriteLine(currentDomain.FriendlyName);//获取应用程序域的名称
       }

    }

 

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

 

我们在来还原一下问题，

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).

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

//类库  

 public class DemoClass1:MarshalByRefObject
    {
        private int count = 0;
        public DemoClass1()
        {
            Console.WriteLine("
----DemoClass Constructor----");
        }

        public void ShowCount(string name)
        {
            count++;
            Console.WriteLine("{0},the count is {1}.", name, count);
        }
        //打印对象所在的应用程序域
        public void ShowAppDomain()
        {
            AppDomain currentDomain = AppDomain.CurrentDomain;//获取代码所在的应用程序域
            Console.WriteLine(currentDomain.FriendlyName);//获取应用程序域的名称
        }

    }

//控制台应用程序      
  static void Main(string[] args)
        {
            Test2();
            //Test3();
        }

        /// <summary>
        /// 在新的应用程序域中创建对象
        /// </summary>
        static void Test2()
        {
            AppDomain currentDomain = AppDomain.CurrentDomain;
            Console.WriteLine(currentDomain.FriendlyName);

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

            DemoClass1 obj;//当前默认应用程序域中开辟的栈空间,注意这里的位置
            //在新的应用程序域中创建对象:程序集“ClassLib, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null”中的类型“ClassLib.DemoClass”未标记为可序列化。
            obj = (DemoClass1)newDomain.CreateInstanceAndUnwrap("ClassLib1", "ClassLib1.DemoClass1"); //新的应用程序域中创建的对象，本地进行反序列化（默认？），还原对象。
            obj.ShowAppDomain();
            obj.ShowCount("Jimmy");
            obj.ShowCount("Jimmy");//基于引用传递时，对象的状态是保留的,count的值基于变化
            Console.Read();
        }

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

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

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

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

        /// <summary>
        /// 在新的应用程序域中,创建两次对象
        /// </summary>
        static void Test3()
        {
            AppDomain currentDomain = Thread.GetDomain();//AppDomain.CurrentDomain;
            Console.WriteLine(currentDomain.FriendlyName);
          
            // create a new appdomain class.
            AppDomain newDomain = AppDomain.CreateDomain("NewDomain");

            DemoClass1 obj, obj2;
      
            //在新的应用程序域中创建对象
            obj=(DemoClass1)newDomain.CreateInstanceAndUnwrap("ClassLib1", "ClassLib1.DemoClass1");
            obj.ShowAppDomain();
            obj.ShowCount("Jimmy");
            obj.ShowCount("Jimmy");
            //Console.Read();

            obj2 = (DemoClass1)newDomain.CreateInstanceAndUnwrap("ClassLib1", "ClassLib1.DemoClass1");
            obj2.ShowAppDomain();
            obj2.ShowCount("Zhang");
            obj2.ShowCount("Zhang");
            Console.Read();
        }

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

分析结果：在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...