C# 通過 AppDomain 應用程式域實作程式集動态解除安裝或加載

　　AppDomain 表示應用程式域，它是一個應用程式在其中執行的獨立環境。每個應用程式隻有一個主應用程式域，但是一個應用程式可以建立多個子應用程式域。

　　是以可以通過 AppDomain 建立新的應用程式域，在新建立的子應用程式域中加載執行程式集并且在執行完畢後釋放程式集資源，來實作系統在運作狀态下，程式集的動态加載或解除安裝，進而達到系統運作中程式集熱更新的目的。

　　所謂應用程式域，.Net引入的一個概念，指的是一種邊界，它辨別了代碼的運作範圍，在其中産生的任何行為，包括異常都不會影響到其他應用程式域，起到安全隔離的效果。也可以看成是一個輕量級的程序。

一個程序可以包含多個應用程式域，各個域之間互相獨立。如下是一個.net程序的組成（圖檔來自網絡）

以下為整個原理的實作代碼

主應用程式入口：

using Kernel.ServiceAgent;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.Remoting;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Kernel.App
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("");

            using (ServiceManager<IObjcet> manager = new ServiceManager<IObjcet>()) 
            {
                string result = manager.Proxy.Put("apprun one");
                Console.WriteLine(result);
                Console.WriteLine("");
                Console.WriteLine("                         Thread AppDomain info                             ");
                Console.WriteLine(manager.CotrProxy.FriendlyName);
                Console.WriteLine(Thread.GetDomain().FriendlyName);
                Console.WriteLine(manager.CotrProxy.BaseDirectory);
                Console.WriteLine(manager.CotrProxy.ShadowCopyFiles);
                Console.WriteLine("");
            }

            Console.ReadLine();
        }
    }
}

建立新的應用程式域并且在新的應用程式域中調用透明代理類:

using Kernel.Interface;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Security.Policy;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Kernel.ServiceAgent
{
    public class ServiceManager<T> : IDisposable where T : class
    {
        private AppDomain ctorProxy = null;

        /// <summary>
        /// 應用程式運作域容器
        /// </summary>
        public AppDomain CotrProxy
        {
            get { return ctorProxy; }
        }

        private T proxy = default(T);

        public T Proxy
        {
            get
            {
                if (proxy == null)
                {
                    proxy = (T)InitProxy(AssemblyPlugs);
                }
                return proxy;
            }
        }

        private string assemblyPlugs;

        /// <summary>
        /// 外挂插件程式集目錄路徑
        /// </summary>
        public string AssemblyPlugs
        {
            get {
                assemblyPlugs = ConfigHelper.GetVaule("PrivatePath");
                if (assemblyPlugs.Equals("")){
                    assemblyPlugs = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Plugins");
                }
                if (!Directory.Exists(assemblyPlugs)) 
                {
                    Directory.CreateDirectory(assemblyPlugs);
                }
                return assemblyPlugs;
            }
            set { assemblyPlugs = value; }
        }

        public ServiceManager()
        {
            if (proxy == null)
            {
                proxy = (T)InitProxy(AssemblyPlugs);
            }
        }

        private T InitProxy(string assemblyPlugs)
        {
            try
            {
                //AppDomain.CurrentDomain.SetShadowCopyFiles();
                //Get and display the friendly name of the default AppDomain.
                //string callingDomainName = Thread.GetDomain().FriendlyName;

                //Get and display the full name of the EXE assembly.
                //string exeAssembly = Assembly.GetEntryAssembly().FullName;
                //Console.WriteLine(exeAssembly);

                AppDomainSetup ads = new AppDomainSetup();
                ads.ApplicationName = "Shadow";

                //應用程式根目錄
                ads.ApplicationBase = AppDomain.CurrentDomain.BaseDirectory;

                //子目錄（相對形式）在AppDomainSetup中加入外部程式集的所在目錄，多個目錄用分号間隔
                ads.PrivateBinPath = assemblyPlugs;
                //設定緩存目錄
                ads.CachePath = ads.ApplicationBase;
                //擷取或設定訓示影像複制是打開還是關閉
                ads.ShadowCopyFiles = "true";
                //擷取或設定目錄的名稱，這些目錄包含要影像複制的程式集
                ads.ShadowCopyDirectories = ads.ApplicationBase;

                ads.DisallowBindingRedirects = false;
                ads.DisallowCodeDownload = true;
                
                ads.ConfigurationFile = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile;

                //Create evidence for the new application domain from evidence of
                Evidence adevidence = AppDomain.CurrentDomain.Evidence;
                
                // Create the second AppDomain.
                ctorProxy = AppDomain.CreateDomain("AD #2", adevidence, ads);
                
                //Type.GetType("Kernel.TypeLibrary.MarshalByRefType").Assembly.FullName
                string assemblyName = Assembly.GetExecutingAssembly().GetName().FullName;
                //string assemblyName = typeof(MarshalByRefType).Assembly.FullName

                // Create an instance of MarshalByRefObject in the second AppDomain. 
                // A proxy to the object is returned.

                Console.WriteLine("CtorProxy:" + Thread.GetDomain().FriendlyName);

                //TransparentFactory factory = (IObjcet)ctorProxy.CreateInstance("Kernel.TypeLibrary",
　　　　　　　　　　　　　　 "Kernel.TypeLibrary.TransparentFactory").Unwrap();
                TransparentAgent factory = (TransparentAgent)ctorProxy.CreateInstanceAndUnwrap(assemblyName, 
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　typeof(TransparentAgent).FullName);
                
                Type meetType = typeof(T);
                string typeName = AssemblyHelper.CategoryInfo(meetType);

                object[] args = new object[0];
                string assemblyPath = ctorProxy.SetupInformation.PrivateBinPath;

                //IObjcet ilive = factory.Create(@"E:\Plug\Kernel.SimpleLibrary.dll", "Kernel.SimpleLibrary.PlugPut", args);
                T obj = factory.Create<T>(assemblyPath, typeName, args);

                return obj;
            }
            catch (System.Exception)
            {
                throw;
            }
        }

        /// <summary>
        /// 解除安裝應用程式域
        /// </summary>
        public void Unload()
        {
            try
            {
                if (ctorProxy != null)
                {
                    AppDomain.Unload(ctorProxy);
                    ctorProxy = null;
                }
            }
            catch(Exception)
            {
                throw;
            }
        }

        public void Dispose()
        {
            this.Unload();
        }
    }
}

建立應用程式代理類:

using Kernel.Interface;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace Kernel.ServiceAgent
{
    public class TransparentAgent : MarshalByRefObject
    {
        private const BindingFlags bfi = BindingFlags.Instance | BindingFlags.Public | BindingFlags.CreateInstance;

        public TransparentAgent() { }

        /// <summary> Factory method to create an instance of the type whose name is specified,
        /// using the named assembly file and the constructor that best matches the specified parameters. </summary>
        /// <param name="assemblyFile"> The name of a file that contains an assembly where the type named typeName is sought. </param>
        /// <param name="typeName"> The name of the preferred type. </param>
        /// <param name="constructArgs"> An array of arguments that match in number, order,
　　　　 /// and type the parameters of the constructor to invoke, or null for default constructor. </param>
        /// <returns> The return value is the created object represented as IObjcet. </returns>
        public IObjcet Create(string assemblyFile, string typeName, object[] args)
        {
            return (IObjcet)Activator.CreateInstanceFrom(assemblyFile, typeName, false, bfi, null, args, null, null).Unwrap();
        }

        public T Create<T>(string assemblyPath, string typeName, object[] args)
        {
            string assemblyFile = AssemblyHelper.LoadAssemblyFile(assemblyPath, typeName);
            return (T)Activator.CreateInstanceFrom(assemblyFile, typeName, false, bfi, null, args, null, null).Unwrap();
        }
    }
}

所有涉及到需要動态加載或釋放的資源，都需要放在代理類中進行操作，隻有在此代理類中進行托管的代碼才是屬于建立的應用程式域的操作。

using Kernel.Interface;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Kernel.ServiceAgent
{
    public class AssemblyHelper
    {
        /// <summary>
        /// 擷取泛型類中指定屬性值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public static string CategoryInfo(Type meetType)
        {
            object[] attrList = meetType.GetCustomAttributes(typeof(CategoryInfoAttribute), false);
            if (attrList != null)
            {
                CategoryInfoAttribute categoryInfo = (CategoryInfoAttribute)attrList[0];
                return categoryInfo.Category;
            }
            return "";
        }

        public static string LoadAssemblyFile(string assemblyPlugs, string typeName)
        {
            string path = string.Empty;
            DirectoryInfo d = new DirectoryInfo(assemblyPlugs);
            foreach (FileInfo file in d.GetFiles("*.dll"))
            {
                Assembly assembly = Assembly.LoadFile(file.FullName);
                Type type = assembly.GetType(typeName, false);
                if (type != null)
                {
                    path = file.FullName;
                }
            }
            return path;
        }
    }
}

讀取配置檔案資訊:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Configuration;

namespace Kernel.ServiceAgent
{
    public class ConfigHelper
    {
        public static string GetVaule(string configName)
        {
            string configVaule = ConfigurationManager.AppSettings[configName];
            if (configVaule != null && configVaule != "")
            {
                return configVaule.ToString();
            }
            return "";
        }
    }
}

配置檔案相關配置資訊:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <startup> 
        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />
    </startup>
    <appSettings>
      <add key="PrivatePath" value="E:\Plugins"/>
    </appSettings>
</configuration>

建立接口資訊:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Kernel.Interface
{
    [CategoryInfo("Kernel.SimpleLibrary.PlugPut", "")]
    public interface IObjcet
    {
        void Put();

        string Put(string plus);
    }
}

建立接口自定義屬性:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Kernel.Interface
{
    /// <summary>
    /// 設定接口實作類自定義标注屬性
    /// </summary>
    /// 
   [AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, Inherited = false, AllowMultiple = false)]
    public class CategoryInfoAttribute : Attribute
    {
        public string Category { get; set; }

        public string Describtion { get; set; }

        /// <summary>
        /// 設定實作類自定義标注屬性
        /// </summary>
        /// <param name="category"></param>
        /// <param name="describtion"></param>
        public CategoryInfoAttribute(string category, string describtion)
        {
            this.Category = category;
            this.Describtion = describtion;
        }
    }
}

建立繼承至IObjcet接口帶有具體操作的實作類：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Kernel.Interface;

namespace Kernel.SimpleLibrary
{
    [Serializable]
    public class PlugPut : MarshalByRefObject, IObjcet
    {

        private string plugName = "my plugName value is default!";

        public string PlugName
        {
            get { return plugName; }
            set { plugName = value; }
        }

        public PlugPut() { }
             

        public PlugPut(string plusName) 
        {
            this.PlugName = plusName;
        }

        public void Put()
        {
            Console.WriteLine("Default plug value is:" + plugName);
        }

        public string Put(string plus)
        {
            Console.WriteLine("Put plus value is:" + plus);
            return ("-------------------- PlugPut result info is welcome -------------------------");
        }
    }
}

　　繼承至IObjcet接口帶有具體操作的實作類，就是屬于需要動态替換更新的程式集，是以最好将其編譯在一個單獨的程式集中，插件目錄在配置檔案中可配置，示例中放置在E:\Plugins 目錄下，示例中代碼最後将生成 Kernel.SimpleLibrary.DLL ，最後将編譯好的程式集放置在 E:\Plugins\Kernel.SimpleLibrary.DLL 路徑下，程式運作後将加載此程式集，加載完畢運作完畢後并釋放此程式集。

　　以下兩句較為重要，最好設定一下，不設定的後果暫時沒有嘗試

　　//擷取或設定訓示影像複制是打開還是關閉

　　ads.ShadowCopyFiles = "true";

　　//擷取或設定目錄的名稱，這些目錄包含要影像複制的程式集

　　ads.ShadowCopyDirectories = ads.ApplicationBase;

　　當程式運作起來後，程式集加載之後會在設定的應用程式域緩存目錄中複制一份程式集的副本，然後運作副本中的程式集，釋放掉本身加載的程式集。以上示例中會在主程式目錄下生成一個Shadow 目錄，此目錄下包含了程式集的副本檔案。

小節:

　　如果在另一個AppDomain 中加載程式集，然後擷取Type，最後在主AppDomain中使用CreateInstance中的Type重載建立對象，結果會是Type所屬的程式集會被加入到目前AppDomain中，然後Type的執行個體會在目前AppDomain中建立。

C# 通過 AppDomain 應用程式域實作程式集動态解除安裝或加載

繼續閱讀

在 Visual Studio 調試器（C#、C++、Visual Basic、F#）中指定符号 (.pdb) 和源檔案

科學技術服務#軟體應用程式開發計算機程式設計#IT服務網站建設資訊技術平台服務#程式設計#程式員#取名公司起名

洞見未來vue3.0新篇章

解決[SetAllPropertiesRule]{Server/Service/Connector} Setting property 'maxTheads' to '500' did not fin

MFC中視窗最小化到托盤處

Spring Boot：延遲初始化與自定義橫幅

spring 擷取自定義配置檔案properties中參數

Java窗體應用程式人事管理系統web人資招聘員工勞資jsp源碼mysql

實用｜關于Kafka入門，看這裡！kafka有四個核心APl，它們分别是ProducerAPl，它允許應用程式向一個或多

3D遊戲3D素材資源zip壓縮解決方案

TCP連接配接狀态詳細解釋

【GitLab】693- 用 GitLab 做 CI/CD 是什麼感覺，太強了！！

89熊貓好物釋出新筆記。在小紅書上，一個備受矚目的賬号釋出了一篇新的筆記，吸引了大量粉絲的關注。這個賬号就是89熊貓好物

分享開源Cesium地形制作工具

Cesium格式3dtile制作工具

一文掃盲：Windows桌面應用程式開發架構都有哪些？