Come posso determinare le dipendenze di un'applicazione .NET?

StackOverflow https://stackoverflow.com/questions/227886

Domanda

Come posso determinare le dipendenze di un'applicazione .NET? Dependency Walker funziona con le app gestite? Ho scaricato l'ultimo e ho provato a profilare l'app, ma esce semplicemente senza molte spiegazioni. Se non funziona con .NET, allora c'è qualche altro strumento che potrebbe aiutarmi a eseguire il debug di un problema di caricamento della DLL in fase di esecuzione?

È stato utile?

Soluzione

Il walker di dipendenze funziona sui normali binari win32. Tutte le DLL ed exe di .NET hanno una piccola parte di intestazione stub che le fa apparire come normali binari, ma tutto ciò che dice sostanzialmente è "caricare il CLR" - quindi è tutto ciò che ti dirà il walker delle dipendenze.

Per sapere su quali elementi si basa effettivamente l'app .NET, puoi utilizzare l'eccezionalmente eccellente . Riflettore NET di Red Gate. (EDIT: Nota che .NET Reflector ora è un prodotto a pagamento. ILSpy è gratuito, open source e molto simile.)

Carica la tua DLL al suo interno, fai clic con il pulsante destro del mouse e scegli "Analizza": vedrai un " Dipende da " oggetto che ti mostrerà tutte le altre DLL (e metodi all'interno di quelle DLL) di cui ha bisogno.

A volte può diventare più complicato, in quanto la tua app dipende da X dll e X dll è presente, ma per qualsiasi motivo non può essere caricata o localizzata in fase di esecuzione.

Per risolvere questo tipo di problemi, Microsoft ha un Assembly Binding Log Viewer che può mostrarti cosa sta succedendo in fase di esecuzione

Altri suggerimenti

Trovo la piccola utility AsmSpy uno strumento prezioso per la risoluzione dei problemi con il caricamento degli assembly. Elenca tutti i riferimenti di assembly di assembly gestiti, comprese le versioni di assembly.

Eseguilo nel prompt dei comandi nella directory del .dll con i seguenti argomenti: 

asmspy . all

screenshot di output asmspy

Installalo rapidamente con Chocolatey: 

choco install asmspy

Apri il file assembly in ILDASM e guarda @ the .assembly extern in MANIFEST

Per sfogliare le dipendenze del codice .NET, è possibile utilizzare le funzionalità dello strumento NDepend. Lo strumento propone:

Ad esempio tale query può apparire come: 

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 }

E il risultato è simile: (notare la metrica del codice profondità , 1 è per i chiamanti diretti, 2 per i chiamanti dei chiamanti diretti ...) (notare anche il pulsante Esporta in grafico per esportare il risultato della query in un Call Graph )

Dipendenze NDepend che sfogliano la query C # LINQ

Il grafico delle dipendenze è simile a:

Grafico delle dipendenze NDepend

La matrice di dipendenza è simile a:

NDepend Dependency Matrix

La matrice di dipendenza è di fatto meno intuitiva rispetto al grafico, ma è più adatta a sfogliare sezioni complesse di codice come:

NDepend Matrix vs Graph

Disclaimer: lavoro per NDepend

Non è necessario scaricare e installare app o strumenti shareware. Puoi farlo programmaticamente da .NET usando Assembly.GetReferencedAssemblies () 

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

Se si utilizza la toolchain Mono, è possibile utilizzare the < code> monodis utility con l'argomento --assemblyref per elencare le dipendenze di un assembly .NET. Funzionerà su entrambi i file .exe e .dll .

Esempio di utilizzo: 

monodis --assemblyref somefile.exe

Esempio di output (.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

Esempio di output (.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

Abilita la registrazione dell'associazione dell'assieme imposta il valore del registro EnableLog in HKLM \ Software \ Microsoft \ Fusion su 1. Nota che è necessario riavviare l'applicazione (utilizzare iisreset) affinché le modifiche abbiano effetto.

Suggerimento: ricordati di disattivare la registrazione della fusione quando hai finito poiché è prevista una penalità per le prestazioni per averlo attivato.

È divertente che ho avuto un problema simile e non ho trovato nulla di adatto ed ero a conoscenza del buon vecchio Dipendente Walker, quindi alla fine ne ho scritto uno io.

Questo riguarda in particolare .NET e mostrerà in modo ricorsivo quali riferimenti ha (e manca) un assembly. Mostrerà anche le dipendenze delle librerie native.

È gratuito (per uso personale) e disponibile qui per chiunque sia interessato: www.netdepends.com

www.netdepends.com

Feedback di benvenuto.

http://www.amberfish.net/

ChkAsm ti mostrerà tutte le dipendenze di un determinato assembly in una sola volta, comprese le versioni, e ti consentirà facilmente di cercare gli assembly nell'elenco. Funziona molto meglio a questo scopo di ILSpy ( http://ilspy.net/ ), che è quello che usavo per questo compito.

Un altro utile componente aggiuntivo di Reflector che utilizzo è il Matrice della struttura di dipendenza . È davvero bello vedere quali classi usano cosa. Inoltre è gratuito.

Prova a compilare il tuo assembly .NET con l'opzione --staticlink: " Namespace.Assembly " . Questo costringe il compilatore a inserire tutte le dipendenze al momento della compilazione. Se viene rilevata una dipendenza a cui non viene fatto riferimento, verrà in genere visualizzato un messaggio di avviso o di errore con il nome dell'assembly.

Namespace.Assembly è l'assembly che sospetti abbia il problema di dipendenza. In genere, il semplice collegamento statico di questo assembly farà riferimento in modo transitorio a tutte le dipendenze.

La migliore app che vedo e utilizzo, mostra DLL perse / problematiche: http://www.dependencywalker.com/

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top