Como determino as dependências de um aplicativo .NET? Faz Dependency Walker trabalho com aplicativos gerenciados? Eu baixei o mais recente e tentei criar o perfil do aplicativo, mas ele sai sem muitas explicações. Se não funcionar com o .NET, há alguma outra ferramenta que me ajudaria a depurar um problema de carregamento de DLL em tempo de execução?

Dependency walker funciona em binários win32 normais. Todas as DLLs e exe do .NET têm uma pequena parte do cabeçalho de stub que os faz parecer binários normais, mas tudo o que basicamente diz é "carregar o CLR" - isso é tudo o que o dependency walker lhe dirá.

Para ver em quais coisas seu aplicativo .NET realmente depende, você pode usar o tremendamente excelente refletor .NET da Red Gate. (EDITAR: Observe que o .NET Reflector agora é um produto pago. ILSpy é gratuito, de código aberto e muito semelhante.)

Carregue sua DLL nela, clique com o botão direito e escolha 'Analisar' - você verá um item "Depends On" que mostrará todas as outras DLLs (e métodos dentro dessas DLLs) de que precisa.

Às vezes, pode ficar mais complicado, pois seu aplicativo depende de X dll e X dll está presente, mas por qualquer motivo não pode ser carregado ou localizado em tempo de execução.

Para solucionar esses tipos de problemas, a Microsoft tem um Assembly Binding Log Viewer que pode mostrar o que está acontecendo no tempo de execução

Acho o pequeno utilitário AsmSpy uma ferramenta inestimável para resolver problemas com o carregamento de assemblies. Ele lista todas as referências de assembly de assemblies gerenciados, incluindo versões de assembly.

Execute-o em um prompt de comando no diretório do .dllcom os seguintes argumentos:

asmspy . all

Instale-o rapidamente com Chocolatey:

choco install asmspy

Abra o arquivo de montagem no ILDASM e procure @ the .assembly extern no MANIFEST

Para navegar pelas dependências do código .NET, você pode usar os recursos da ferramenta NDepend. A ferramenta propõe:

• um gráfico de dependência
• uma matriz de dependência ,
• e também algumas consultas C # LINQ podem ser editadas (ou geradas) para navegar pelas dependências.

Por exemplo, essa consulta pode ser semelhante a:

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 seu resultado se parece com: (observe a profundidade da métrica do código , 1 é para chamadores diretos, 2 para chamadores de chamadores diretos ...) (observe também o botão Exportar para Gráfico para exportar o resultado da consulta para um Gráfico de Chamada )

O gráfico de dependência se parece com:

A matriz de dependência é semelhante a:

A matriz de dependência é de fato menos intuitiva do que o gráfico, mas é mais adequada para navegar por seções complexas de código como:

Aviso: Eu trabalho para NDepend

Você não precisa baixar e instalar aplicativos ou ferramentas shareware. Você pode fazer isso de forma programática a partir do .NET usandoAssembly.GetReferencedAssemblies()

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

Se você estiver usando o conjunto de ferramentas Mono, poderá usar o monodisutilitário com o --assemblyrefargumento para listar as dependências de um assembly .NET. Isso funcionará em arquivos .exee .dll.

Exemplo de uso:

monodis --assemblyref somefile.exe

Exemplo de saída (.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

Saída de exemplo (.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

Habilitar log de associação de assembly defina o valor do registro EnableLog em HKLM \ Software \ Microsoft \ Fusion como 1. Observe que você deve reiniciar seu aplicativo (use iisreset) para que as alterações tenham efeito.

Dica: Lembre-se de desligar o registro de fusão quando terminar, pois há uma penalidade de desempenho em tê-lo ativado.

É engraçado que eu tive um problema semelhante e não encontrei nada adequado e conhecia o bom e velho Dependency Walker, então no final eu mesmo escrevi um.

Isso lida especificamente com o .NET e mostrará quais referências um assembly tem (e faltam) recursivamente. Ele também mostrará as dependências da biblioteca nativa.

É gratuito (para uso pessoal) e está disponível aqui para todos os interessados: www.netdepends.com

Feedback bem-vindo.

http://www.amberfish.net/

O ChkAsm mostrará todas as dependências de um determinado assembly de uma vez, incluindo as versões, e permitirá que você procure por assemblies na lista. Funciona muito melhor para esse propósito do que ILSpy ( http://ilspy.net/ ), que é o que eu costumava usar para essa tarefa.

Outro suplemento útil do Reflector que uso é a Matriz de estrutura de dependência . É muito bom ver quais classes usam o quê. Além disso, é grátis.

Tente compilar seu conjunto .NET com a opção --staticlink:"Namespace.Assembly". Isso força o compilador a obter todas as dependências em tempo de compilação. Se encontrar uma dependência não referenciada, ele dará um aviso ou mensagem de erro geralmente com o nome desse assembly.

Namespace.Assemblyé o assembly que você suspeita que tenha o problema de dependência. Normalmente, apenas vincular estaticamente este assembly fará referência a todas as dependências transitivamente.

Melhor aplicativo que vejo e uso, mostra dlls perdidas / problemáticas: http://www.dependencywalker.com/