Je trouve le petit utilitaire AsmSpy un outil précieux pour résoudre les problèmes de chargement des assemblages. Il répertorie toutes les références d'assemblage des assemblages gérés, y compris les versions d'assemblage.

Exécuter dans une invite de commande dans le répertoire de la .dll, avec les arguments suivants:

asmspy . all

Installez-le rapidement avec Chocolatey:

choco install asmspy

Ouvrez le fichier d'assemblage dans ILDASM et regardez @ the .assembly extern dans le manifeste

Pour parcourir les dépendances de code. Net, vous pouvez utiliser les fonctionnalités de L'outil NDepend. L'outil propose:

• un graphe de dépendance
• A matrice de dépendance ,
• et aussi certaines requêtes C# LINQ peuvent être éditées (ou générées) pour parcourir les dépendances.

Par exemple, une telle requête peut ressembler à:

from m in Methods 
let depth = m.DepthOfIsUsing("NHibernate.NHibernateUtil.Entity(Type)") 
where depth  >= 0 && m.IsUsing("System.IDisposable")
orderby depth
select new { m, depth }

Et son résultat ressemble à: (notez la métrique de code Profondeur , 1 est pour les appelants directs, 2 pour les appelants de direct appelant...) (notez également le bouton Exporter vers le graphique pour exporter le résultat de la requête vers un graphique D'appel )

Le graphique de dépendance ressemble à:

La matrice de dépendance ressemble à:

La matrice de dépendance est de facto moins intuitive que le graphique, mais elle est plus adaptée pour parcourir des sections complexes de code comme:

avertissement: je travaille pour NDepend

Vous n'avez pas besoin de télécharger et d'installer des applications ou des outils shareware. Vous pouvez le faire par programme à partir de. net en utilisant Assembly.GetReferencedAssemblies()

Assembly.LoadFile(@"app").GetReferencedAssemblies()

Si vous utilisez la chaîne D'outils Mono, vous pouvez utiliser l'utilitaire monodis avec l'argument --assemblyref pour lister les dépendances d'un assembly.net. Cela fonctionnera à la fois sur les fichiers .exe et .dll.

Exemple d'utilisation:

monodis --assemblyref somefile.exe

Exemple de sortie (.exe):

$ monodis --assemblyref monop.exe
AssemblyRef Table
1: Version=4.0.0.0
    Name=System
    Flags=0x00000000
    Public Key:
0x00000000: B7 7A 5C 56 19 34 E0 89
2: Version=4.0.0.0
    Name=mscorlib
    Flags=0x00000000
    Public Key:
0x00000000: B7 7A 5C 56 19 34 E0 89

Exemple de sortie (.dll):

$ monodis --assemblyref Mono.CSharp.dll
AssemblyRef Table
1: Version=4.0.0.0
    Name=mscorlib
    Flags=0x00000000
    Public Key:
0x00000000: B7 7A 5C 56 19 34 E0 89
2: Version=4.0.0.0
    Name=System.Core
    Flags=0x00000000
    Public Key:
0x00000000: B7 7A 5C 56 19 34 E0 89
3: Version=4.0.0.0
    Name=System
    Flags=0x00000000
    Public Key:
0x00000000: B7 7A 5C 56 19 34 E0 89
4: Version=4.0.0.0
    Name=System.Xml
    Flags=0x00000000
    Public Key:
0x00000000: B7 7A 5C 56 19 34 E0 89

Activer la journalisation des liaisons d'assemblage définissez la valeur de registre EnableLog dans HKLM\Software\Microsoft\Fusion sur 1. Notez que vous devez redémarrer votre application (utilisez iisreset) pour que les modifications aient un effet.

Astuce: N'oubliez pas de désactiver la journalisation fusion lorsque vous avez terminé, car il y a une pénalité de performance pour l'activer.

C'est drôle, j'ai eu un problème similaire et je n'ai rien trouvé de convenable et j'étais conscient de la bonne vieille dépendance Walker donc à la fin j'en ai écrit un moi-même.

Cela traite spécifiquement de. NET et montrera quelles Références un assembly A (et manquantes) récursivement. Il montrera également les dépendances de la bibliothèque native.

C'est gratuit (pour un usage personnel) et disponible ici pour toute personne intéressée: www.netdepends.com

Commentaires bienvenus.

Http://www.amberfish.net/

ChkAsm vous montrera toutes les dépendances d'un assembly particulier à la fois, y compris les versions, et vous permettra facilement de rechercher des assemblys dans la liste. Fonctionne beaucoup mieux à cet effet que ILSpy (http://ilspy.net/), ce que j'avais l'habitude d'utiliser pour cette tâche.

Un autre Add-in réflecteur pratique que j'utilise est la matrice de structure de dépendance . C'est vraiment génial de voir quelles classes utilisent quoi. En Plus, c'est gratuit.

Essayez de compiler votre assembly. net avec l'option --staticlink:"Namespace.Assembly" . Cela force le compilateur à extraire toutes les dépendances au moment de la compilation. S'il rencontre une dépendance qui n'est pas référencée, il donnera un message d'avertissement ou d'erreur généralement avec le nom de cet assembly.

Namespace.Assembly est l'assemblage que vous soupçonnez d'avoir le problème de dépendance. Typiquement, la liaison statique de cet assembly référencera toutes les dépendances de manière transitive.

Meilleure application que je vois et utilise, afficher les DLL manquées/problématiques: http://www.dependencywalker.com/