Comment déterminer les dépendances d'une application .NET? Est -ce que la dépendance Walker travail avec des applications gérées? J'ai téléchargé la dernière version et essayé de profiler l'application, mais elle se termine sans grande explication. Si cela ne fonctionne pas avec .NET, existe-t-il un autre outil qui m'aiderait à déboguer un problème de chargement de DLL au moment de l'exécution?

Dependency Walker fonctionne sur les binaires win32 normaux. Toutes les dll et exe .NET ont une petite partie d'en-tête de stub qui les fait ressembler à des binaires normaux, mais tout ce qu'il dit, c'est "charger le CLR" - c'est donc tout ce que l'explorateur de dépendances vous dira.

Pour voir sur quels éléments s'appuie réellement votre application .NET, vous pouvez utiliser le très excellent réflecteur .NET de Red Gate. (EDIT: Notez que .NET Reflector est maintenant un produit payant. ILSpy est gratuit et open source et très similaire.)

Chargez votre DLL dedans, faites un clic droit et choisissez «Analyser» - vous verrez alors un élément «Dépend de» qui vous montrera toutes les autres dll (et méthodes à l'intérieur de ces dll) dont il a besoin.

Cela peut parfois devenir plus compliqué, car votre application dépend de X dll et X dll est présent, mais pour une raison quelconque, elle ne peut pas être chargée ou localisée au moment de l'exécution.

Pour résoudre ce type de problèmes, Microsoft dispose d'un visualiseur de journal de liaison d'assembly qui peut vous montrer ce qui se passe au moment de l'exécution

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

Exécutez-le dans une invite de commande dans le répertoire du .dllavec les arguments suivants:

asmspy . all

Installez-le rapidement avec Chocolatey:

choco install asmspy

Ouvrez le fichier d'assembly dans ILDASM et regardez @ le .assembly extern dans le MANIFEST

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

• un graphe de dépendance
• une matrice de dépendances ,
• et aussi certaines requêtes C # LINQ peuvent être modifié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 profondeur de la métrique du code , 1 est pour les appelants directs, 2 pour les appelants des appelants directs ...) (notez également le bouton Exporter vers le graphique pour exporter le résultat de la requête vers un graphique d'appel )

Le graphe de dépendance ressemble à ceci:

La matrice de dépendances ressemble à ceci:

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

Avis de non-responsabilité: 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 utilisantAssembly.GetReferencedAssemblies()

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

Si vous utilisez la chaîne d'outils Mono, vous pouvez utiliser l' monodisutilitaire avec l' --assemblyrefargument pour répertorier les dépendances d'un assembly .NET. Cela fonctionnera sur les fichiers .exeet .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 de la liaison d'assembly 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.

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

C'est drôle, j'ai eu un problème similaire et je n'ai rien trouvé de convenable et j'étais au courant du bon vieux Dependency Walker alors à la fin j'en ai écrit un moi-même.

Cela traite spécifiquement de .NET et montrera les références à un assembly (et manquantes) de manière récursive. Il affichera é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

Vos commentaires sont les bienvenus.

http://www.amberfish.net/

ChkAsm vous montrera toutes les dépendances d'un assemblage 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'utilisais pour cette tâche.

Un autre complément pratique de Reflector que j'utilise est la matrice de structure de dépendance . C'est vraiment génial de voir quelles classes utilisent quoi. De 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 non référencée, il émettra un message d'avertissement ou d'erreur généralement avec le nom de cet assembly.

Namespace.Assemblyest l'assembly que vous soupçonnez d'avoir le problème de dépendance. En général, la liaison statique de cet assembly référencera toutes les dépendances de manière transitoire.

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