Observação
O acesso a essa página exige autorização. Você pode tentar entrar ou alterar diretórios.
O acesso a essa página exige autorização. Você pode tentar alterar os diretórios.
O Visual Studio inclui um conjunto integrado poderoso de ferramentas de criação e depuração de projetos. Este artigo descreve como o Visual Studio pode ajudá-lo a encontrar problemas em seu código usando saída de build, análise de código, ferramentas de depuração e testes de unidade.
Você entendeu como o editor funciona e criou um pouco de código. Agora, você deseja garantir que o código funcione corretamente. No Visual Studio, como na maioria dos IDEs, há duas fases para fazer o código funcionar: criar o código para capturar e resolver erros de projeto e compilador e executar o código para localizar erros dinâmicos e em tempo de execução.
Compilar seu código
Há dois tipos básicos de configuração de build: Depuração e Versão. A configuração de depuração produz um executável mais lento e maior que permite uma experiência mais avançada de depuração interativa em tempo de execução. O executável Debug nunca deve ser enviado. A configuração de versão cria um executável mais rápido e otimizado que é apropriado para ser enviado (pelo menos da perspectiva do compilador). A configuração de build padrão é Debug.
A maneira mais fácil de criar seu projeto é pressionar F7, mas você também pode iniciar o build selecionando Compilar>solução de build no menu principal.
Você pode observar o processo de build na janela Saída na parte inferior da interface do usuário do Visual Studio (interface do usuário). Erros, avisos e operações de build são exibidos aqui. Se você tiver erros (ou se tiver avisos acima de um nível configurado), o build falhará. Você pode selecionar os erros e avisos para ir para a linha em que ocorreram. Recompile seu projeto pressionando F7 novamente (para recompilar somente os arquivos com erros) ou Ctrl+Alt+F7 (para uma recompilação limpa e completa).
Há duas janelas com guias na janela de resultados abaixo do editor: a janela Saída , que contém a saída bruta do compilador (incluindo mensagens de erro); e a janela Lista de Erros , que fornece uma lista classificável e filtre de todos os erros e avisos.
Quando a compilação for bem-sucedida, você verá resultado assim na janela Saída
Examinar a lista de erros
A menos que você não tenha feito nenhuma modificação no código compilado anteriormente e com êxito, provavelmente terá um erro. Se você é novo em codificação, você provavelmente tem muitos deles. Às vezes, os erros são óbvios, como um erro de sintaxe simples ou um nome de variável incorreto e, às vezes, são difíceis de entender, com apenas um código enigmático para guiá-lo. Para obter uma exibição mais limpa dos problemas, navegue até a parte inferior da janela de saída do build e selecione a guia Lista de Erros . Essa ação leva você a uma exibição mais organizada dos erros e avisos para seu projeto e fornece algumas opções extras também.
Selecione a linha de erro na janela Lista de Erros e vá para a linha onde o erro ocorre. (Ou ative os números de linha pressionando Ctrl+P, digitando números de linha e, em seguida, escolhendo Ativar ou desativar números de linha dos resultados. Essa ação é a maneira mais rápida de acessar a caixa de diálogo Opções em que você pode ativar números de linha.)
Pressione Ctrl+G para ir rapidamente para o número de linha em que o erro ocorreu.
O Visual Studio identifica esse erro com um sublinhado vermelho de "rabiscos". Passe o mouse sobre ele para obter mais detalhes. Faça a correção e ela desaparecerá, embora você possa introduzir um novo erro com a correção. (Essa ação é chamada de "regressão".)
Percorra a lista de erros e resolva todos os erros em seu código.
Examinar erros em detalhes
Muitos erros podem não fazer sentido para você, formulados como estão nos termos do compilador. Nesses casos, talvez você precise de informações adicionais. Na janela Lista de Erros , você pode executar uma pesquisa automática do Bing para obter mais informações sobre o erro ou aviso. Clique com o botão direito do mouse na linha correspondente e selecione Mostrar Ajuda de Erro no menu de contexto ou selecione o valor do código de erro hiperlinkado na coluna Código da Lista de Erros.
Dependendo das configurações, o navegador da Web exibe os resultados da pesquisa para o código de erro e o texto ou uma guia é aberta dentro do Visual Studio e mostra os resultados da pesquisa do Bing. Os resultados são de várias fontes diferentes na Internet e talvez você não ache tudo útil.
Usar a análise de código
Os analisadores de código procuram problemas comuns de código que podem levar a erros de tempo de execução ou problemas no gerenciamento de código.
Análise de código do C# e do Visual Basic
O Visual Studio inclui um conjunto interno de analisadores da Plataforma do Compilador .NET que examinam o código C# e o Visual Basic à medida que você digita. Você pode instalar mais analisadores como uma extensão do Visual Studio ou como um pacote NuGet. Se forem encontradas violações de regra, elas serão relatadas na Lista de Erros e no editor de código como uma alternância sob o código ofensivo.
Análise de código C++
Para analisar o código C++, execute a análise de código estático. Tenha o hábito de executá-lo depois de limpar os erros óbvios que impedem um build bem-sucedido e leve algum tempo para resolver os avisos que ele pode produzir. Você pode se poupar de algumas dores de cabeça no futuro, além de aprender algumas técnicas de estilo de código.
Pressione Alt+F11 (ou selecione Analisar>Executar análise de código na solução no menu superior) para iniciar a análise de código estático.
Quaisquer avisos novos ou atualizados aparecem na guia Lista de Erros na parte inferior do IDE. Selecione um aviso para ir até ele no código.
Usar Ações Rápidas para corrigir ou refatorar código
Ações Rápidas, disponíveis no ícone de lâmpada ou chave de fenda, permitem refatorar o código diretamente. Eles são uma maneira fácil de corrigir avisos comuns de forma rápida e eficaz no código C#, C++e Visual Basic. Para acessá-los, clique com o botão direito do mouse em um botão de aviso e selecione Ações Rápidas e refatorações. Ou, quando o cursor estiver na linha com o rabisco colorido, pressione Ctrl+. ou selecione a lâmpada, a lâmpada de erro ou o ícone de chave de fenda na margem. Em seguida, o Visual Studio mostra uma lista de possíveis correções ou refatorações que você pode aplicar a essa linha de código.
Ações Rápidas podem ser usadas onde quer que os analisadores de código determinem que há uma oportunidade de corrigir, refatorar ou melhorar seu código. Selecione em qualquer linha de código, clique com o botão direito do mouse para abrir o menu de contexto e selecione Ações Rápidas e refatorações. Se as opções de refatoração ou melhoria estiverem disponíveis, elas serão exibidas. Caso contrário, a mensagem Nenhuma ação rápida disponível aqui será exibida no canto inferior esquerdo do IDE.
Com a experiência, você pode usar rapidamente as teclas de direção e Ctrl+. Para verificar se há oportunidades de refatoração fáceis e limpar seu código!
Executar limpeza de código
O Visual Studio fornece a formatação sob demanda do arquivo de código C#, incluindo preferências de estilo de código, por meio do botão Limpeza de Código na parte inferior do editor.
Além de formatar seu arquivo para espaços, recuos e assim por diante, a Limpeza de Código também aplica um conjunto de convenções de estilo de código que você define. Suas preferências para cada estilo de código são lidas do arquivo EditorConfig, se você tiver um para o projeto ou das configurações de estilo de código na caixa de diálogo Opções .
Depure o código que está em execução
Agora que você criou seu código com êxito e executou uma pequena limpeza, execute-o pressionando F5 ou selecionando Depurar>Iniciar Depuração. Essa ação inicia seu aplicativo em um ambiente de depuração para que você possa observar seu comportamento em detalhes. O IDE do Visual Studio é alterado enquanto seu aplicativo está em execução: na configuração de janela padrão, a janela Saída é substituída por duas novas, a janela com guias Autos/Locais/Observação e a janela com guias Pilha de Chamadas/Pontos de Interrupção/Configurações de Exceção/Saída. Essas janelas têm várias guias que permitem inspecionar e avaliar as variáveis, threads, pilhas de chamadas e outros comportamentos do aplicativo à medida que ele é executado.
Interrompa seu aplicativo pressionando Shift+F5 ou clicando no botão Parar . Ou você pode simplesmente fechar a janela principal do aplicativo (ou a caixa de diálogo de linha de comando).
Se seu código foi executado perfeitamente e exatamente como esperado, parabéns! No entanto, às vezes, seu código pode parar de responder ou falhar ou fornecer alguns resultados estranhos. Nesse caso, você deve tentar encontrar a origem desses problemas e corrigir os bugs.
Definir pontos de interrupção simples
Pontos de parada são o recurso mais básico e essencial da depuração confiável. Um ponto de interrupção indica onde o Visual Studio deve suspender o código em execução para que você possa dar uma olhada nos valores das variáveis ou no comportamento da memória ou se um branch de código está sendo executado. Você não precisa recriar um projeto depois de definir e remover pontos de interrupção.
Defina um ponto de interrupção clicando na margem mais distante da linha em que você deseja que a quebra ocorra ou pressione F9 para definir um ponto de interrupção na linha de código atual. Quando você executa seu código, ele pausa (ou interrompe) antes que as instruções para essa linha de código sejam executadas.
Os usos comuns para pontos de interrupção incluem:
Para restringir a origem de um programa de falha ou sem resposta, disperse pontos de interrupção em todo o código da chamada de método que você acha que está causando a falha. Enquanto você executa o código no depurador, remova e redefina os pontos de interrupção mais próximos até encontrar a linha de código problemática. Consulte a próxima seção para saber como executar o código no depurador.
Quando você introduzir um novo código, defina um ponto de interrupção no início dele e execute o código para garantir que ele esteja se comportando conforme o esperado.
Se você implementou um comportamento complicado, defina pontos de interrupção para o código algorítmico para poder inspecionar os valores das variáveis e dos dados quando o programa for interrompido.
Se você estiver escrevendo código em C ou C++, use pontos de interrupção para parar o código e inspecionar valores de endereço (procure por NULL) e contagens de referência ao depurar falhas relacionadas à memória.
Para obter mais informações sobre como usar pontos de interrupção, consulte Usar pontos de interrupção no depurador do Visual Studio.
Inspecionar seu código em tempo de execução
Quando o código em execução atinge um ponto de interrupção e pausa, a linha de código marcada em amarelo (a instrução atual) ainda não foi executada. Neste ponto, talvez você queira executar a instrução atual e inspecionar os valores alterados. Você pode usar vários comandos de step para rodar o código no depurador. Se o código marcado for uma chamada de método, você poderá intervir nele pressionando F11. Você também pode saltar a linha de código pressionando F10. Para obter mais comandos e detalhes sobre como percorrer o código, leia Navegar pelo código usando o depurador.
Na ilustração anterior, você pode avançar o depurador com uma instrução pressionando F10 ou F11 (como não há nenhuma chamada de método aqui, ambos os comandos têm o mesmo resultado).
Enquanto o depurador está pausado, você pode inspecionar suas variáveis e pilhas de chamadas para entender o que está acontecendo. Os valores estão nos intervalos que você espera ver? As chamadas estão sendo feitas na ordem certa?
Passe o mouse sobre uma variável para ver seu valor e referências atuais. Se você vir um valor que não esperava, provavelmente terá um bug no código anterior ou de chamada. Para saber mais, veja Primeira olhada no Depurador do Visual Studio.
Além disso, o Visual Studio exibe a janela Ferramentas de Diagnóstico , na qual você pode observar o uso de CPU e memória do aplicativo ao longo do tempo. Posteriormente, no desenvolvimento de seu aplicativo, você pode usar essas ferramentas para procurar o uso intenso de CPU ou alocação inesperada de memória. Use-o com a janela Inspeção e pontos de interrupção para determinar o que está causando uso pesado inesperado ou recursos não lançados. Para obter mais informações, consulte First look at profiling tools (C#, Visual Basic, C++, F#).
Executar testes de unidade
Os testes de unidade são sua primeira linha de defesa contra bugs de código porque, quando feitos corretamente, eles testam uma única "unidade" de código, normalmente uma única função e são mais fáceis de depurar do que seu programa completo. O Visual Studio instala as estruturas de teste de unidade da Microsoft para código gerenciado e nativo. Use uma estrutura de teste de unidade para criar testes de unidade, executá-los e relatar os resultados desses testes. Execute novamente os testes de unidade ao fazer alterações, para testar se o código ainda está funcionando corretamente. Com o Visual Studio Enterprise Edition, você pode executar testes automaticamente após cada build.
Para começar, leia Gerar testes de unidade para teste de fuzz usando o IntelliTest.
Para saber mais sobre testes de unidade no Visual Studio e como eles podem ajudá-lo a criar um código de melhor qualidade, leia as noções básicas de teste de unidade.