Como depurar uma dll referenciada (com pdb)

Eu tenho duas soluções no meu espaço de trabalho, digamos A e B.

A solução A é um projeto mais antigo que terminei de codificar há algum tempo. Na solução B, preciso usar algumas classes da solução A. Para fazer isso, adiciono uma referência à dll de um dos projetos na solução A.

O problema é quando tento depurar. Quero poder entrar no código de A também. O Visual Studio não pode carregar o código para essas classes ("Não há código fonte disponível para o local atual.") E só posso ver a desmontagem, o que não é útil.

A única maneira que conheço para depurar classes da solução A é executando a solução B, desanexe todos os processos (no item de menu Debug) e anexe o processo da solução A.

No entanto, isso é muito inconveniente e só posso depurar A ou B de uma vez.

Existe uma maneira de permitir entrar no código de dlls referenciadas (para as quais eu tenho o código-fonte)?

Solução: Meu erro foi pensar que um projeto só pode fazer parte de uma única solução. De fato, um projeto pode fazer parte de qualquer número de soluções.
Quando precisar fazer referência ao projeto antigo, basta adicionar o projeto à solução. Isso é feito clicando com o botão direito do mouse na nova solução em Solution Explorer> Add> Existing Project.
Em seguida, você poderá adicionar a referência do projeto. Como outros escreveram, você provavelmente deve evitar completamente o uso de referências de DLL ao seu próprio código (ou outro código que você precise alterar e depurar).

Uma referência muito boa sobre como as soluções devem ser projetadas pode ser encontrada no MSDN .

Se você tiver uma referência de projeto , ela deverá funcionar imediatamente.

Se for uma referência de arquivo (dll), você precisará que os símbolos de depuração (o arquivo "pdb") estejam na mesma pasta que a dll. Verifique se seus projetos estão gerando símbolos de depuração (propriedades do projeto => Build => Advanced => Output / Debug Info = full); e se você copiou a dll, coloque o pdb com ela.

Você também pode carregar símbolos diretamente no IDE se não quiser copiar nenhum arquivo, mas é mais trabalhoso.

A opção mais fácil é usar referências de projeto!

Eu tive o mesmo problema. Ele é o que eu encontrei:

1) verifique se todos os projetos estão usando o mesmo Framework (isso é crucial!)

2) em Ferramentas / Opções> Depuração> Geral, verifique se "Ativar apenas meu código (somente gerenciado) NÃO está marcado

3) em Ferramentas / Opções> Depuração> Símbolos, limpe todos os símbolos em cache, desmarque e exclua todos os locais da pasta na caixa de listagem "Locais do arquivo de símbolos (.pdb)", exceto os "Servidores de símbolos da Microsoft" padrão, mas também desmarque-os também. Exclua também todos os caminhos estáticos na caixa de texto "Símbolos de cache neste diretório". Clique no botão "Esvaziar cache de símbolos". Por fim, verifique se o botão de opção "Somente módulos especificados" está marcado.

4) no menu Build / Configuration Manager para todos os projetos, verifique se a configuração está no modo Debug.

Outro ponto a ser lembrado, verifique se as DLLs referenciadas não estão instaladas no GAC. Após o teste, instalei minhas dlls no GAC para fazer o teste no nível do sistema. Mais tarde, quando tive que depurar meu código novamente, não pude entrar nos assemblies referenciados até excluí-los do GAC.

Etapa 1: Vá para Ferramentas -> Opção -> Depuração

Etapa 2: desmarque Ativar apenas meu código

Etapa 3: desmarque a opção Exigir que o arquivo de origem corresponda exatamente à versão original

Etapa 4: desmarque a opção Etapa sobre propriedades e operadores

Eu tinha os *.pdbarquivos na mesma pasta e usei as opções do Arindam , mas ainda não funcionou. Acontece que eu precisava ativar a opção Ativar depuração de código nativo, que pode ser encontrada em Propriedades do projeto> Depuração .

Quando você deseja definir um ponto de interrupção no código-fonte de uma dll referenciada, primeiro verifique se você tem um arquivo pdb disponível para ele. Em seguida, você pode simplesmente abrir o arquivo de código-fonte relacionado e definir um ponto de interrupção por lá. O arquivo de origem não precisa fazer parte da sua solução. Conforme explicado em Como posso definir um ponto de interrupção no código referenciado no Visual Studio?

Você pode revisar seus pontos de interrupção através da janela de pontos de interrupção, disponível em Depuração -> Windows -> Pontos de interrupção.

Essa abordagem tem o benefício de que você não precisa adicionar um projeto existente à sua solução apenas para fins de depuração, pois deixá-lo de fora economizou muito tempo de criação. Evidentemente, construir uma solução com apenas um projeto é muito mais rápido do que construir uma solução com muitos deles.

Verifique se sua DLL não está registrada no GAC. O Visual Studio usará a versão no GAC e provavelmente não terá informações de depuração.

Não quero incluir um projeto de biblioteca de classes externa em algumas das minhas soluções, por isso passo para os assemblies que consumo de maneira diferente.

Minhas soluções têm um diretório "Assemblies comuns" que contém minhas próprias DLLs de outros projetos. As DLLs a que me refiro também têm seus arquivos PDB acompanhantes para depuração.

Para depurar e definir pontos de interrupção, defino um ponto de interrupção na origem do aplicativo consumidor em que estou chamando um método ou construtor do assembly e depois passo INTO (F11) a chamada do método / construtor.

O depurador carregará o arquivo de origem do assembly no VS e novos pontos de interrupção dentro do assembly podem ser definidos nesse ponto.

Não é simples, mas funciona se você não deseja incluir uma nova referência de projeto e simplesmente deseja fazer referência a uma montagem compartilhada.

Isso deve funcionar. Eu costumava depurar um arquivo .exe e uma dll ao mesmo tempo! O que eu sugiro é 1) Inclua o caminho da dll no seu projeto B, 2) Em seguida, compile em depurar o seu projeto A 3) Controle que o caminho aponte no arquivo A dll e de pdb .... 4) Depois disso, você inicie na depuração do projeto B e, se estiver tudo bem, você poderá depurar nos dois projetos!

A maneira mais direta que encontrei usando o VisualStudio 2019 para depurar uma biblioteca externa à qual você está fazendo referência no NuGet é executando as seguintes etapas:

1. Ferramentas> Opções> Depuração> Geral> Desmarque 'Ativar apenas meu código'

2. Vá para Assembly Explorer> Abrir no cache de pacotes do NuGet

3. Digite o nome do pacote NuGet que você deseja depurar no campo de pesquisa e clique em 'OK'

4. No Assembly Explorer, clique com o botão direito do mouse no assembly importado e selecione 'Generate Pdb'

5. Selecione um caminho personalizado no qual deseja salvar o arquivo .PDB e a estrutura para a qual deseja que isso seja gerado.

   

6. Copie o arquivo .PDB da pasta gerada para sua pasta Debug e agora você pode definir pontos de interrupção no código de biblioteca deste assembly