C#综合揭秘——细说进程、应用程序域与上下文之间的关系

最新推荐文章于 2024-01-31 22:44:11 发布

cainong2005

最新推荐文章于 2024-01-31 22:44:11 发布

阅读量297

点赞数 1

文章标签：进程应用程序域应用上下文

原文地址：https://www.cnblogs.com/leslies2/archive/2012/03/06/2379235.html#d

引言
本文主要是介绍进程（Process）、应用程序域（AppDomain）、.NET上下文（Context）的概念与操作。
虽然在一般的开发当中这三者并不常用，但熟悉三者的关系，深入了解其作用，对提高系统的性能有莫大的帮助。
在本篇最后的一节当中将会介绍到三者与线程之间的关系，希望对多线程开发人员能提供一定的帮助。

因为时间仓促，文中有错误的地方敬请点评。

目录
一、进程的概念与作用
二、应用程序域
三、深入了解.NET上下文

四、进程应用程序域与线程的关系

一、进程的概念与作用

进程（Process）是Windows系统中的一个基本概念，它包含着一个运行程序所需要的资源。进程之间是相对独立的，一个进程无法直接访问另一个进程的数据（除非利用分布式计算方式），一个进程运行的失败也不会影响其他进程的运行，Windows系统就是利用进程把工作划分为多个独立的区域的。进程可以理解为一个程序的基本边界。

1.1 Process 的属性与方法
在 System.Diagnostics 命名空间当中存在Process类，专门用于管理进程的开始、结束，访问进程中的模块，获取进程中的线程，设定进程的优先级别等。

表1.0 显示了Process类的常用属性：

除了上述属性，Process类也定义了下列经常使用的方法：

Process类的详细信息可以参考 http://msdn.microsoft.com/zh-cn/library/system.diagnostics.process.aspx

下面将举例介绍一下Process的使用方式

1.2 建立与销毁进程

利用 Start 与Kill 方法可以简单建立或者销毁进程，下面例子就是利用 Start 方法启动记事本的进程，并打开File.txt文件。2秒钟以后，再使用 Kill 方法销毁进程，并关闭记事本。

static void Main(string[] args)
{
   Process process = Process.Start("notepad.exe","File.txt");
   Thread.Sleep(2000);
   process.Kill();
}

1.3 列举计算机运行中的进程
在表1.0 中可以看到，使用 GetProcesses 方法可以获取本地计算机上正在运行的每一个进程列表。
而进程的 Id 属性是每个进程的唯一标志，通过下面的方法，可以显示当前计算机运行的所有进程信息。

因为篇幅关系，下面例子只获取前10个进程。

static void Main(string[] args)
{
    var processList = Process.GetProcesses()
        .OrderBy(x=>x.Id)
        .Take(10);
    foreach (var process in processList)
         Console.WriteLine(string.Format("ProcessId is:{0} \t ProcessName is:{1}",process.Id, process.ProcessName));
         Console.ReadKey();
}

运行结果

如果已知进程的Id，就可以通过 GetProcessById 方法获取对应的进程。

static void Main(string[] args)
{
    try
    {
        var process = Process.GetProcessById(1772);
        Console.WriteLine("Process name is:" + process.ProcessName);
   }
   catch (ArgumentException ex)
   {
        Console.WriteLine("Process is nothing!");
   }
   Console.ReadKey();
}

同样地，你也可能通过GetProcessByName方法获取多个对应名称的进程。

注意：如果不能找到当前ID的进程，系统就会抛出ArgumentException异常。所以使用方法 GetProcessById 获取进程时应该包含在 try{...} catch{..} 之内。

1.4 获取进程中的多个模块

在表1.0 中包含了Process类的Modules属性，通过此属性可能获取进程中的多个模块。

这些模块可以是以 *.dll 结尾的程序集，也可以是 *.exe 结尾的可执行程序。

下面的例子就是通过 Process 的 GetCurrentProcess 方法获取当前运行的进程信息，然后显示当前进程的多个模块信息。

static void Main(string[] args)
        {
            var moduleList = Process.GetCurrentProcess().Modules;
            foreach (System.Diagnostics.ProcessModule module in moduleList)
                Console.WriteLine(string.Format("{0}\n  URL:{1}\n  Version:{2}",
                    module.ModuleName,module.FileName,module.FileVersionInfo.FileVersion));
            Console.ReadKey();
        }

二、应用程序域

使用.NET建立的可执行程序 *.exe，并没有直接承载到进程当中，而是承载到应用程序域（AppDomain）当中。应用程序域是.NET引入的一个新概念，它比进程所占用的资源要少，可以被看作是一个轻量级的进程。
在一个进程中可以包含多个应用程序域，一个应用程序域可以装载一个可执行程序（*.exe）或者多个程序集（*.dll）。这样可以使应用程序域之间实现深度隔离，即使进程中的某个应用程序域出现错误，也不会影响其他应用程序域的正常运作。

当一个程序集同时被多个应用程序域调用时，会出现两种情况：
第一种情况：CLR分别为不同的应用程序域加载此程序集。
第二种情况：CLR把此程序集加载到所有的应用程序域之外，并实现程序集共享，此情况比较特殊，被称作为Domain Neutral。

2.1 AppDomain的属性与方法

在System命名空间当中就存在AppDomain类，用管理应用程序域。下面是AppDomain类的常用属性：

AppDomain类中有多个事件，用于管理应用程序域生命周期中的不同部分。

下面将举例详细介绍一下AppDomain的使用方式

2.2 在AppDomain中加载程序集
由表2.1中可以看到，通过CreateDomain方法可以建立一个新的应用程序域。

下面的例子将使用CreateDomain建立一个应用程序域，并使用Load方法加载程序集Model.dll。最后使用GetAssemblies方法，列举此应用程序域中的所有程序集。

static void Main(string[] args)
        {
            var appDomain = AppDomain.CreateDomain("NewAppDomain");
            appDomain.Load("Model");
            foreach (var assembly in appDomain.GetAssemblies())
                Console.WriteLine(string.Format("{0}\n----------------------------",
                    assembly.FullName));
            Console.ReadKey();
        }

运行结果

注意：当加载程序集后，就无法把它从AppDomain中卸载，只能把整个AppDomain卸载。

当需要在AppDomain加载可执行程序时，可以使用ExecuteAssembly方法。

AppDomain.ExecuteAssembly("Example.exe");

2.3 卸载AppDomain
通过Unload可以卸载AppDomain，在AppDomain卸载时将会触发DomainUnload事件。

下面的例子中，将会使用CreateDomain建立一个名为NewAppDomain的应用程序域。然后建立AssemblyLoad的事件处理方法，在程序集加载时显示程序集的信息。最后建立DomainUnload事件处理方法，在AppDomain卸载时显示卸载信息。

static void Main(string[] args)
        {
            //新建名为NewAppDomain的应用程序域
            AppDomain newAppDomain = AppDomain.CreateDomain("NewAppDomain");
            //建立AssemblyLoad事件处理方法
            newAppDomain.AssemblyLoad +=
                (obj, e) =>
                {
                    Console.WriteLine(string.Format("{0} is loading!", e.LoadedAssembly.GetName()));
                };
            //建立DomainUnload事件处理方法
            newAppDomain.DomainUnload +=
                (obj, e) =>
                {
                    Console.WriteLine("NewAppDomain Unload!");
                };
            //加载程序集
            newAppDomain.Load("Model");
            //模拟操作
            for (int n = 0; n < 5; n++)
                Console.WriteLine("  Do Work.......!");
             //卸载AppDomain
            AppDomain.Unload(newAppDomain);
            Console.ReadKey();
        }

运行结果

2.4 在AppDomain中建立程序集中指定类的对象

使用CreateInstance方法，能建立程序集中指定类的对像。但使用此方法将返回一个ObjectHandle对象，若要将此值转化为原类型，可调用Unwrap方法。

下面例子会建立Model.dll程序集中的Model.Person对象。

namespace Test
{
     public class Program
    {
         static void Main(string[] args)
         {
             var person=(Person)AppDomain.CurrentDomain
                          .CreateInstance("Model","Model.Person").Unwrap();
             person.ID = 1;
             person.Name = "Leslie";
             person.Age = 29;
             Console.WriteLine(string.Format("{0}'s age is {1}!",person.Name,person.Age));
             Console.ReadKey();
         }
    }
}

namespace Model
{
    public class Person
    {
          public int ID
          {
              get;
              set;
          }
          public string Name
          {
               get;
               set;
          }
          public int Age
          {
               get;
               set;
          }
     }
}

三、深入了解.NET上下文

3.1 .NET上下文的概念
应用程序域是进程中承载程序集的逻辑分区，在应用程序域当中，存在更细粒度的用于承载.NET对象的实体，那就.NET上下文Context。
所有的.NET对象都存在于上下文当中，每个AppDomain当中至少存在一个默认上下文（context 0）。

一般不需要指定特定上下文的对象被称为上下文灵活对象（context-agile），建立此对象不需要特定的操作，只需要由CLR自行管理，一般这些对象都会被建立在默认上下文当中。

图3.0

3.2 透明代理

在上下文的接口当中存在着一个消息接收器负责检测拦截和处理信息，当对象是MarshalByRefObject的子类的时候，CLR将会建立透明代理，实现对象与消息之间的转换。
应用程序域是CLR中资源的边界，一般情况下，应用程序域中的对象不能被外界的对象所访问。而MarshalByRefObject 的功能就是允许在支持远程处理的应用程序中跨应用程序域边界访问对象，在使用.NET Remoting远程对象开发时经常使用到的一个父类。
此文章针对的是进程与应用程序域的作用，关于MarshalByRefObject的使用已经超越了本文的范围，关于.NET Remoting 远程对象开发可参考：“回顾.NET Remoting分布式开发”。

3.3 上下文绑定
当系统需要对象使用消息接收器机制的时候，即可使用ContextBoundObject类。ContextBoundObject继承了MarshalByRefObject类，保证了它的子类都会通过透明代理被访问。
在第一节介绍过：一般类所建立的对象为上下文灵活对象（context-agile），它们都由CLR自动管理，可存在于任意的上下文当中。而 ContextBoundObject 的子类所建立的对象只能在建立它的对应上下文中正常运行，此状态被称为上下文绑定。其他对象想要访问ContextBoundObject 的子类对象时，都只能通过代透明理来操作。

下面的例子，是上下文绑定对象与上下文灵活对象的一个对比。Example 是一个普通类，它的对象会运行在默认上下文当中。而ContextBound类继承了ContextBoundObject，它的对象是一个上下文绑定对象。ContextBound还有一个Synchronization特性，此特性会保证ContextBound对象被加载到一个线程安全的上下文当中运行。另外，Context类存在ContextProperties属性，通过此属性可以获取该上下文的已有信息。

class Program
    {
        public class Example
        {
            public void Test()
            {
                ContextMessage("Example Test\n");
            }
            //访问上下文绑定对象测试
            public void Sync(ContextBound contextBound)
            {
                contextBound.Test("Example call on contextBound\n");
            }
        }

        [Synchronization]
        public class ContextBound:ContextBoundObject
        {
            public void Test(string message)
            {
                ContextMessage(message);
            }
        }

        static void Main(string[] args)
        {
            Example example = new Example();
            example.Test();
            ContextBound contextBound = new ContextBound();
            contextBound.Test("ContentBound Test\n");
            example.Sync(contextBound);
            Console.ReadKey();
        }

        //显示上下文信息
        public static void ContextMessage(string data)
        {
            Context context = Thread.CurrentContext;
            Console.WriteLine(string.Format("{0}ContextId is {1}", data, context.ContextID));
            foreach (var prop in context.ContextProperties)
                Console.WriteLine(prop.Name);
            Console.WriteLine();
        }
    }

运行结果

由运行结果可以发现，example对象一般只会工作于默认上下文context 0 当中，而contextBound则会工作于线程安全的上下文 context 1当中。当example需要调用contextBound对象时，就会通过透明代理把消息直接传递到context 1中。

四、进程、应用程序域、线程的相互关系

4.1 跨AppDomain运行代码

在应用程序域之间的数据是相对独立的，当需要在其他AppDomain当中执行当前AppDomain中的程序集代码时，可以使用CrossAppDomainDelegate委托。把CrossAppDomainDelegate委托绑定方法以后，通过AppDomain的DoCallBack方法即可执行委托。

static void Main(string[] args)
        {
            Console.WriteLine("CurrentAppDomain start!");
            //建立新的应用程序域对象
            AppDomain newAppDomain = AppDomain.CreateDomain("newAppDomain");
            //绑定CrossAppDomainDelegate的委托方法
            CrossAppDomainDelegate crossAppDomainDelegate=new CrossAppDomainDelegate(MyCallBack);
            //绑定DomainUnload的事件处理方法
            newAppDomain.DomainUnload += (obj, e) =>
            {
                Console.WriteLine("NewAppDomain unload!");
            };
            //调用委托
            newAppDomain.DoCallBack(crossAppDomainDelegate);
            AppDomain.Unload(newAppDomain) ;
            Console.ReadKey();
        }

        static public void MyCallBack()
        {
            string name = AppDomain.CurrentDomain.FriendlyName;
            for(int n=0;n<4;n++)
            Console.WriteLine(string.Format( "  Do work in {0}........" , name));
        }

运行结果

4.2 跨AppDomain的线程

线程存在于进程当中，它在不同的时刻可以运行于多个不同的AppDomain当中。它是进程中的基本执行单元，在进程入口执行的第一个线程被视为这个进程的主线程。在.NET应用程序中，都是以Main()方法作为入口的，当调用此方法时系统就会自动创建一个主线程。线程主要是由CPU寄存器、调用栈和线程本地存储器（Thread Local Storage，TLS）组成的。CPU寄存器主要记录当前所执行线程的状态，调用栈主要用于维护线程所调用到的内存与数据，TLS主要用于存放线程的状态信息。
关于线程的介绍，可参考 “C#综合揭秘——细说多线程（上）”、“C#综合揭秘——细说多线程（下）”

下面的例子将介绍一下如何跨AppDomain使用线程，首先建立一个ConsoleApplication项目，在执行时输入当前线程及应用程序域的信息，最后生成Example.exe的可执行程序。

static void Main(string[] args)
        {
            var message = string.Format("  CurrentThreadID is:{0}\tAppDomainID is:{1}",
                Thread.CurrentThread.ManagedThreadId, AppDomain.CurrentDomain.Id);
            Console.WriteLine(message);
            Console.Read();
        }

然后再新建一个ConsoleApplication项目，在此项目中新一个AppDomain对象，在新的AppDomain中通过ExecuteAssembly方法执行Example.exe程序。

static void Main(string[] args)
        {
            //当前应用程序域信息
            Console.WriteLine("CurrentAppDomain start!");
            ShowMessage();
            
            //建立新的应用程序域对象
            AppDomain newAppDomain = AppDomain.CreateDomain("newAppDomain");
            //在新的应用程序域中执行Example.exe
            newAppDomain.ExecuteAssembly("Example.exe");

            AppDomain.Unload(newAppDomain);
            Console.ReadKey();
        }

        public static void ShowMessage()
        {
            var message = string.Format("  CurrentThreadID is:{0}\tAppDomainID is:{1}",
                Thread.CurrentThread.ManagedThreadId, AppDomain.CurrentDomain.Id);
            Console.WriteLine(message);
        }

运行结果

可见，ID等于9的线程在不同时间内分别运行于AppDomain 1与AppDomain 2当中。

4.3 跨上下文的线程
线程既然能够跨越AppDomain的边界，当然也能跨越不同的上下文。

下面这个例子中，线程将同时运行在默认上下文与提供安全线程的上下文中。

class Program
    {
        [Synchronization]
        public class ContextBound : ContextBoundObject
        {
            public void Test()
            {
                ShowMessage();
            }
        }

        static void Main(string[] args)
        {
            //当前应用程序域信息
            Console.WriteLine("CurrentAppDomain start!");
            ShowMessage();

            //在上下文绑定对象中运行线程
            ContextBound contextBound = new ContextBound();
            contextBound.Test();
            Console.ReadKey();
        }

        public static void ShowMessage()
        {
            var message = string.Format("  CurrentThreadID is:{0}\tContextID is:{1}",
                 Thread.CurrentThread.ManagedThreadId, Thread.CurrentContext.ContextID);
            Console.WriteLine(message);
        }
    }

运行结果

本篇总结

进程（Process）、线程（Thread）、应用程序域（AppDomain）、上下文（Context）的关系如图5.0，一个进程内可以包括多个应用程序域，也有包括多个线程，线程也可以穿梭于多个应用程序域当中。但在同一个时刻，线程只会处于一个应用程序域内。线程也能穿梭于多个上下文当中，进行对象的调用。

虽然进程、应用程序域与上下文在平常的开发中并非经常用到，但深入地了解三者的关系，熟悉其操作方式对合理利用系统的资源，提高系统的效率是非常有意义的。

尤其是三者与线程之间的关系尤为重要，特别是在一个多线程系统中，如果不能理清其关系而盲目使用多线程，容易造成资源抢占与死锁之类的错误。

图5.0

cainong2005

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
C#综合揭秘——细说进程、应用程序域与上下文之间的关系

原文地址：https://www.cnblogs.com/leslies2/archive/2012/03/06/2379235.html#d引言本文主要是介绍进程（Process）、应用程序域（AppDomain）、.NET上下文（Context）的概念与操作。虽然在一般的开发当中这三者并不常用，但熟悉三者的关系，深入了解其作用，对提高系统的性能有莫大的帮助。在本篇最后的一节当中将会介绍到三者与...
复制链接

扫一扫