वर्तमान में लोड की गई असेंबली के माध्यम से आप कैसे लूप करते हैं?

Question

मुझे अपने एएसपी.NET एप्लिकेशन में "निदान" पृष्ठ मिला है जो डेटाबेस कनेक्शन को सत्यापित करने जैसी चीजें करता है, वर्तमान ऐप सेटिंग्स और कनेक्शनस्ट्रिंग आदि प्रदर्शित करता है। इस पृष्ठ का एक अनुभाग महत्वपूर्ण प्रकार के असेंबली संस्करण प्रदर्शित करता है पूरे प्रयोग में इस्तेमाल किया गया, लेकिन मैं यह नहीं समझ पाया कि सभी भारित असेंबली के संस्करणों को प्रभावी ढंग से कैसे दिखाया जाए।

वर्तमान में संदर्भित सभी को संदर्भित करने और/या लोड किए गए एक .NET अनुप्रयोग में असेंबली का सबसे प्रभावी तरीका क्या है?

नोट: मुझे फ़ाइल-आधारित विधियों में दिलचस्पी नहीं है, जैसे किसी विशेष निर्देशिका में * .dll के माध्यम से पुनरावृत्ति करना। मुझे इस बात में दिलचस्पी है कि आवेदन वास्तव में का उपयोग कर रहा है।

Answer 1

इस विस्तार विधि में सभी संदर्भित असेंबली मिलती हैं, जो संक्षेप में नेस्टेड असेंबली समेत होती हैं।

चूंकि यह ReflectionOnlyLoad का उपयोग करता है, यह असेंबली को एक अलग ऐपडोमेन में लोड करता है, जिसका लाभ जेआईटी प्रक्रिया में हस्तक्षेप नहीं करने का लाभ होता है।

आप देखेंगे कि MyGetMissingAssembliesRecursive भी है। आप संदर्भित किसी भी लापता असेंबली का पता लगाने के लिए इसका उपयोग कर सकते हैं, लेकिन किसी कारण से वर्तमान निर्देशिका में मौजूद नहीं है। MEF का उपयोग करते समय यह अविश्वसनीय रूप से उपयोगी है। वापसी सूची आपको लापता असेंबली दोनों देगी, और जो इसका मालिक है (इसके माता-पिता)।

/// <summary> 
///  Intent: Get referenced assemblies, either recursively or flat. Not thread safe, if running in a multi 
///  threaded environment must use locks. 
/// </summary> 
public static class GetReferencedAssemblies 
{ 
    static void Demo() 
    { 
     var referencedAssemblies = Assembly.GetEntryAssembly().MyGetReferencedAssembliesRecursive(); 
     var missingAssemblies = Assembly.GetEntryAssembly().MyGetMissingAssembliesRecursive(); 
     // Can use this within a class. 
     //var referencedAssemblies = this.MyGetReferencedAssembliesRecursive(); 
    } 

    public class MissingAssembly 
    { 
     public MissingAssembly(string missingAssemblyName, string missingAssemblyNameParent) 
     { 
      MissingAssemblyName = missingAssemblyName; 
      MissingAssemblyNameParent = missingAssemblyNameParent; 
     } 

     public string MissingAssemblyName { get; set; } 
     public string MissingAssemblyNameParent { get; set; } 
    } 

    private static Dictionary<string, Assembly> _dependentAssemblyList; 
    private static List<MissingAssembly> _missingAssemblyList; 

    /// <summary> 
    ///  Intent: Get assemblies referenced by entry assembly. Not recursive. 
    /// </summary> 
    public static List<string> MyGetReferencedAssembliesFlat(this Type type) 
    { 
     var results = type.Assembly.GetReferencedAssemblies(); 
     return results.Select(o => o.FullName).OrderBy(o => o).ToList(); 
    } 

    /// <summary> 
    ///  Intent: Get assemblies currently dependent on entry assembly. Recursive. 
    /// </summary> 
    public static Dictionary<string, Assembly> MyGetReferencedAssembliesRecursive(this Assembly assembly) 
    { 
     _dependentAssemblyList = new Dictionary<string, Assembly>(); 
     _missingAssemblyList = new List<MissingAssembly>(); 

     InternalGetDependentAssembliesRecursive(assembly); 

     // Only include assemblies that we wrote ourselves (ignore ones from GAC). 
     var keysToRemove = _dependentAssemblyList.Values.Where(
      o => o.GlobalAssemblyCache == true).ToList(); 

     foreach (var k in keysToRemove) 
     { 
      _dependentAssemblyList.Remove(k.FullName.MyToName()); 
     } 

     return _dependentAssemblyList; 
    } 

    /// <summary> 
    ///  Intent: Get missing assemblies. 
    /// </summary> 
    public static List<MissingAssembly> MyGetMissingAssembliesRecursive(this Assembly assembly) 
    { 
     _dependentAssemblyList = new Dictionary<string, Assembly>(); 
     _missingAssemblyList = new List<MissingAssembly>(); 
     InternalGetDependentAssembliesRecursive(assembly); 

     return _missingAssemblyList; 
    } 

    /// <summary> 
    ///  Intent: Internal recursive class to get all dependent assemblies, and all dependent assemblies of 
    ///  dependent assemblies, etc. 
    /// </summary> 
    private static void InternalGetDependentAssembliesRecursive(Assembly assembly) 
    { 
     // Load assemblies with newest versions first. Omitting the ordering results in false positives on 
     // _missingAssemblyList. 
     var referencedAssemblies = assembly.GetReferencedAssemblies() 
      .OrderByDescending(o => o.Version); 

     foreach (var r in referencedAssemblies) 
     { 
      if (String.IsNullOrEmpty(assembly.FullName)) 
      { 
       continue; 
      } 

      if (_dependentAssemblyList.ContainsKey(r.FullName.MyToName()) == false) 
      { 
       try 
       { 
        var a = Assembly.ReflectionOnlyLoad(r.FullName); 
        _dependentAssemblyList[a.FullName.MyToName()] = a; 
        InternalGetDependentAssembliesRecursive(a); 
       } 
       catch (Exception ex) 
       { 
        _missingAssemblyList.Add(new MissingAssembly(r.FullName.Split(',')[0], assembly.FullName.MyToName())); 
       } 
      } 
     } 
    } 

    private static string MyToName(this string fullName) 
    { 
     return fullName.Split(',')[0]; 
    } 
} 

अद्यतन

इस कोड धागा सुरक्षित बनाने के लिए, इसके चारों ओर एक lock डाल दिया। वर्तमान में यह डिफ़ॉल्ट रूप से थ्रेड सुरक्षित नहीं है, क्योंकि यह अपने जादू करने के लिए एक साझा स्थिर वैश्विक चर का संदर्भ देता है।

Answer 2

वर्तमान AppDomain के लिए लोड हो रही है विधानसभाओं:

var referencedAssemblies = someAssembly.GetReferencedAssemblies(); 

ध्यान दें कि यदि विधानसभा एक संदर्भ विधानसभा बी और विधानसभा एक भरी हुई है, कि करता है:

var loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies(); 

विधानसभाओं एक और विधानसभा द्वारा संदर्भित हो रही है यह नहीं दर्शाता कि असेंबली बी भी लोड किया गया है। असेंबली बी केवल तभी लोड किया जाएगा जब इसकी आवश्यकता हो। इसी कारण से, GetReferencedAssemblies()AssemblyNameAssembly उदाहरणों के बजाय उदाहरण देता है।