Comment déterminer les dépendances d'une application .NET?

https://stackoverflow.com/questions/227886

03-07-2019
|

Question

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

La solution

Le gestionnaire de dépendances fonctionne avec les fichiers binaires Win32 normaux. Tous les dll .NET et les exes ont une petite partie en-tête de stub qui les fait ressembler à des binaires normaux, mais tout ce qu’il dit est en gros de "charger le CLR" - C’est tout ce que le promeneur de dépendances vous dira.

Pour savoir sur quoi repose votre application .NET, vous pouvez utiliser l'excellent . Réflecteur NET de Red Gate. (EDIT: notez que .NET Reflector est désormais un produit payant. ILSpy est gratuit et open source et très similaire.)

Chargez votre DLL dans celle-ci, cliquez dessus avec le bouton droit et choisissez "Analyser". Vous verrez alors un message "Dépend de". élément 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é, en ce sens que votre application dépend de la DLL X, et que la DLL X est présente, mais pour une raison quelconque, elle ne peut pas être chargée ou localisée à l'exécution.

Pour résoudre ce type de problèmes, Microsoft dispose d'un Assembly. Visionneuse de journal de reliure qui peut vous montrer ce qui se passe à l'exécution

Autres conseils

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

Exécutez-le à l'invite de commande du répertoire .dll avec les arguments suivants:

asmspy . all

Installez-le rapidement avec Chocolatey:

choco install asmspy

Ouvrez le fichier d'assemblage dans ILDASM et regardez @ l'assembly externe dans le MANIFEST

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
une matrice de dépendance ,
et certaines requêtes C # LINQ peuvent être modifiées (ou générées). 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 est le suivant: (remarquez la métrique du code profondeur , 1 pour les appelants directs, 2 pour les appelants des appelants directs ...) (notez également le bouton Exporter en graphique pour exporter interroger le résultat sur un graphe d'appels )

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 de code complexes telles que:

Avertissement: je travaille pour NDepend

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

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

Si vous utilisez la chaîne d’outils Mono, vous pouvez utiliser la < Utilitaire code> monodis avec l'argument - assemblyref pour répertorier les dépendances d'un assemblage .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'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 soient prises en compte.

Conseil: N'oubliez pas de désactiver la journalisation de la fusion lorsque vous avez terminé, car l'activation de la journalisation est pénalisée.

C’est drôle, j’ai eu un problème similaire, je n’ai rien trouvé qui convienne et je suis au courant du bon vieux Dependency Walker. J’en ai donc écrit un moi-même à la fin.

Ceci traite spécifiquement de .NET et montrera quelles références un assemblage a (et manque) de manière récursive. Cela affichera également les dépendances de bibliothèques natives.

C'est gratuit (pour un usage personnel) et disponible ici pour les personnes intéressées: 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. Cela fonctionne beaucoup mieux à cette fin que ILSpy ( http://ilspy.net/ ), ce que j'avais l'habitude d'utiliser 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 assemblage .NET avec l'option - staticlink: "Namespace.Assembly & ". Cela oblige 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, un message d'avertissement ou d'erreur s'affichera, généralement avec le nom de cet assembly.

Namespace.Assembly est l’assembly que vous suspectez comme ayant le problème de dépendance. Généralement, la liaison statique de cet assemblage référencera toutes les dépendances de manière transitoire.

La meilleure application que je vois et utilise montre les DLL manquantes ou problématiques: http://www.dependencywalker.com/

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow