.NET में असेंबली लोडिंग, ऑपरेटिंग और अनलोडिंग असेंबलिंग

अक्सर, डेवलपर समान कार्यों के साथ मुख्य एल्गोरिथ्म का विस्तार करने के सवाल का सामना करता है। उदाहरण के लिए, विभिन्न सेवाओं के एग्रीगेटर जो उपयोगकर्ता को एकल इंटरफ़ेस प्रदान करते हैं, सैकड़ों सेवा प्रदाताओं से अनुरोध करते हैं। कार्य ऐसा है कि मुख्य कोर एक निश्चित इंटरफ़ेस के विभिन्न कार्यान्वयन के साथ विधानसभाओं को गतिशील रूप से लोड कर सकता है। .NET प्रोग्रामर के लिए कोई भी ओवरवर्क शुरू में यहां अपेक्षित नहीं है। यदि शब्द "प्रतिबिंब" आपको ज्ञात है, तो क्या आप शायद पहले से ही पास होना चाहते हैं? लेकिन इस विषय में हम प्रतिबिंब के बारे में इस तरह से बात नहीं करेंगे ... मैं आपको बताऊंगा कि इसे सबसे "सफाई से" कैसे किया जाए। यानी एक बारीकियों के साथ - जांच के तहत असेंबलियों को उनके संचालन के बाद अनलोड किया जाना चाहिए।


इसलिए कार्य: आपको एक कंसोल एप्लिकेशन बनाने की आवश्यकता है ExtensionLoader, जो स्टार्टअप पर, गतिशील रूप से अपनी निर्देशिका से सभी पुस्तकालयों को लोड करता है जिसमें एक वर्ग पाया गया था जो IExtension इंटरफ़ेस को लागू करता है:

interface IExtension { String GetExtensionName(); } 

पाया पुस्तकालयों को लोड करने के बाद, आवेदन प्रत्येक पाया वर्ग (IExtension के साथ) के लिए एक उदाहरण बनाता है और एकमात्र GetExtensionName () विधि को निष्पादित करता है, परिणाम कंसोल में प्रदर्शित होता है।

यह एक परीक्षण कार्य की तरह लगता है - वास्तव में, ऐसा था ...

इस कार्य में एक अति सूक्ष्म अंतर दिलचस्प था: आवेदन की वास्तुकला इस तरह से निर्मित की जानी चाहिए कि सभी लोड किए गए पुस्तकालयों को अनलोड करना संभव होगा। यहीं से शुरू होती है मस्ती। एक त्वरित googling ने कोई भी तैयार समाधान प्रदान नहीं किया। समस्या के विश्लेषण में एक निश्चित समय लगा और मैं इसे साझा करना चाहता हूं ... रचनात्मक प्रतिक्रिया प्राप्त करने की उम्मीद कर रहा हूं, और व्यर्थ झूठ नहीं बोलना ...

आइए इंटरफ़ेस के विवरण के साथ एक सामान्य पुस्तकालय से शुरू करें। यह अपने आप से एक अलग परियोजना होगी, ताकि यह इस इंटरफ़ेस के सभी कार्यान्वयनों के लिए बिना विस्तार के और सिस्टम के कोर दोनों से जुड़ा हो सके। यह एक तरह की पसंद है, जाहिर है। असाइनमेंट पर हमारी लाइब्रेरी में एक इंटरफ़ेस होगा। यह पहले से ही कार्य में वर्णित है, इसलिए मैं इसे नहीं दोहराऊंगा।

अगला, हम IExtension इंटरफ़ेस को लागू करते हैं। यह भी स्पष्ट है कि यह एक अलग परियोजना होगी, जिसमें हमारे उदाहरण में दिए गए इंटरफ़ेस का एक कार्यान्वयन होगा।

  public class Extension1 : MarshalByRefObject, IExtension { public Extension1() { } public string GetExtensionName() { return "Extension 1 from " + AppDomain.CurrentDomain.FriendlyName; } } 

एक जिज्ञासु पाठक पहले ही कुछ ज्यादतियों पर ध्यान दे चुका है जिसकी उसे यहाँ देखने की उम्मीद नहीं थी। अर्थात्, MarshalByRefObject से विरासत। यहाँ ट्रिक यह है: यदि हम MarshalByRefObject से इनहेरिट नहीं करते हैं, जब प्रतिबिंब का उपयोग करके किसी विधि को निष्पादित करने का प्रयास किया जाता है, तो असेंबली को वर्तमान एप्लिकेशन डोमेन में लोड किया जाएगा, जहां से विधि को बुलाया जाता है। इसका परिणाम असेंबली को उतारने की असंभवता होगी, क्योंकि असेंबली व्यक्तिगत रूप से अनलोड नहीं की जाती हैं (केवल पूरी तरह से पूरे डोमेन द्वारा)। कार्य निष्फल हो जाएगा।

आगे मैं आपको "उबाऊ तरीके" दूंगा जिन्हें आपको देखना नहीं है। इन विधियों को लोडर एप्लिकेशन में एक उदाहरण के रूप में लागू किया जाता है। उनका उद्देश्य विशुद्ध रूप से उपयोगितावादी कार्य है।

  /// <summary> ///    . /// </summary> /// <param name="domain">,      .</param> private static IEnumerable<IExtension> EnumerateExtensions(AppDomain domain) { IEnumerable<string> fileNames = Directory.EnumerateFiles(domain.BaseDirectory, "*.dll"); if (fileNames != null) { foreach (string assemblyFileName in fileNames) { foreach (string typeName in GetTypes(assemblyFileName, typeof(IExtension), domain)) { System.Runtime.Remoting.ObjectHandle handle; try { handle = domain.CreateInstanceFrom(assemblyFileName, typeName); } catch (MissingMethodException) { continue; } object obj = handle.Unwrap(); IExtension extension = (IExtension)obj; yield return extension; } } } } /// <summary> ///    ,    . ///     . /// </summary> /// <param name="assemblyFileName">   </param> /// <param name="interfaceFilter"> </param> /// <param name="domain">   .</param> /// <returns>   .</returns> private static IEnumerable<string> GetTypes(string assemblyFileName, Type interfaceFilter, AppDomain domain) { Assembly asm = domain.Load(AssemblyName.GetAssemblyName(assemblyFileName)); Type[] types = asm.GetTypes(); foreach (Type type in types) { if (type.GetInterface(interfaceFilter.Name) != null) { yield return type.FullName; } } } 

निम्नलिखित दो सरल तरीके भी हैं, लेकिन लेख के संदर्भ में अधिक महत्वपूर्ण हैं। इस तथ्य के कारण विधियां अजीब लग सकती हैं कि उनके पास केवल एक कॉल है, लेकिन ये केवल इस लेख के लिए अनावश्यक कार्यक्षमता को समाप्त करने के परिणाम हैं।

  /// <summary> ///   . /// </summary> /// <param name="path">    .</param> /// <returns>  .</returns> static AppDomain CreateDomain(string path) { AppDomainSetup setup = new AppDomainSetup(); setup.ApplicationBase = path; return AppDomain.CreateDomain("Temporary domain", null, setup); } /// <summary> ///   . /// </summary> /// <param name="domain">  .</param> static void UnloadDomain(AppDomain domain) { AppDomain.Unload(domain); } 

खैर, और अंत में, मुख्य विधि ... जो यह सब "का उपयोग करता है"

  static void Main(string[] args) { //   ,     . AppDomain domain = CreateDomain(Directory.GetCurrentDirectory()); try { //    . IEnumerable<IExtension> extensions = EnumerateExtensions(domain); foreach (IExtension extension in extensions) //   .     . Console.WriteLine(extension.GetExtensionName()); //      .     . UnloadDomain(domain); } finally { domain = null; GC.Collect(2); } Console.ReadKey(); }