J'ai une page "diagnostics" dans mon application ASP.NET qui fait des choses comme vérifier la (les) connexion (s) à la base de données, afficher les appSettings et ConnectionStrings actuels, etc. Une section de cette page affiche les versions d'assembly des types importants utilisés tout au long , mais je ne pouvais pas comprendre comment afficher efficacement les versions de TOUS les assemblys chargés.

Quel est le moyen le plus efficace de déterminer tous les assemblys actuellement référencés et / ou chargés dans une application .NET?

Remarque: je ne suis pas intéressé par les méthodes basées sur des fichiers, comme l'itération via * .dll dans un répertoire particulier. Je suis intéressé par ce que l'application utilise actuellement.

Cette méthode d'extension obtient tous les assemblys référencés, de manière récursive, y compris les assemblys imbriqués.

Lors de son utilisation ReflectionOnlyLoad, il charge les assemblys dans un AppDomain séparé, ce qui présente l'avantage de ne pas interférer avec le processus JIT.

Vous remarquerez qu'il existe également un fichier MyGetMissingAssembliesRecursive. Vous pouvez l'utiliser pour détecter les assemblys manquants qui sont référencés, mais qui ne sont pas présents dans le répertoire actuel pour une raison quelconque. Ceci est incroyablement utile lors de l'utilisation de MEF . La liste de retour vous donnera à la fois l'assembly manquant et à qui il appartient (son parent).

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

Mettre à jour

Pour rendre ce thread de code sûr, mettez un lockautour de lui. Il n'est actuellement pas thread-safe par défaut, car il fait référence à une variable globale statique partagée pour faire sa magie.

Obtenir des assemblys chargés pour le courant AppDomain:

var loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies();

Obtenir les assemblys référencés par un autre assembly:

var referencedAssemblies = someAssembly.GetReferencedAssemblies();

Notez que si l'assemblage A fait référence à l'assemblage B et l'assemblage A est chargé, cela n'implique pas que l'assemblage B est également chargé. L'assemblage B ne sera chargé que si et quand il est nécessaire. Pour cette raison, GetReferencedAssemblies()renvoie des AssemblyNameinstances plutôt que des Assemblyinstances.