Ho una pagina di "diagnostica" nella mia applicazione ASP.NET che fa cose come verificare le connessioni al database, visualizzare le impostazioni di app e le stringhe di connessione correnti, ecc. Una sezione di questa pagina mostra le versioni di assembly di tipi importanti utilizzati in tutto , ma non sono riuscito a capire come mostrare in modo efficace le versioni di TUTTI gli assembly caricati.

Qual è il modo più efficace per capire tutti gli assembly attualmente referenziati e / o caricati in un'applicazione .NET?

Nota: non sono interessato ai metodi basati su file, come l'iterazione di * .dll in una determinata directory. Sono interessato a ciò che l'applicazione sta effettivamente utilizzando in questo momento.

Questo metodo di estensione ottiene tutti gli assembly a cui si fa riferimento, in modo ricorsivo, inclusi gli assembly annidati.

Durante l'utilizzo ReflectionOnlyLoad, carica gli assembly in un AppDomain separato, che ha il vantaggio di non interferire con il processo JIT.

Noterai che c'è anche un file MyGetMissingAssembliesRecursive. È possibile utilizzarlo per rilevare eventuali assembly mancanti a cui viene fatto riferimento, ma non presenti nella directory corrente per qualche motivo. Questo è incredibilmente utile quando si utilizza MEF . La lista di restituzione ti darà sia l'assembly mancante, sia chi lo possiede (il suo genitore).

/// <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];
    }
}

Aggiornare

Per rendere sicuro questo thread di codice, mettici un lockintorno. Attualmente non è thread-safe per impostazione predefinita, poiché fa riferimento a una variabile globale statica condivisa per fare la sua magia.

Ottenere gli assembly caricati per la corrente AppDomain:

var loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies();

Ottenere gli assembly a cui fa riferimento un altro assembly:

var referencedAssemblies = someAssembly.GetReferencedAssemblies();

Si noti che se l'assembly A fa riferimento all'assembly B e l'assembly A è caricato, ciò non implica che l'assembly B sia caricato anche. L'assieme B verrà caricato solo se e quando necessario. Per questo motivo, GetReferencedAssemblies()restituisce le AssemblyNameistanze anzichéAssembly istanze.