Tutorial C# PDF

Contents
Tutoriais do C#
Visão geral
Sobre o Visual Studio
Sobre o editor de código
Sobre projetos e soluções
Mais recursos do Visual Studio
Criar um aplicativo
Crie seu primeiro aplicativo C#
Criar um aplicativo Web
Criar um aplicativo UWP
Criar um aplicativo WPF
Criar um aplicativo do Windows Forms
Tutorial em vídeo – Criar um aplicativo Web ASP.NET Core
1 – Instalar o Visual Studio
2 – Criar seu primeiro aplicativo Web ASP.NET Core
3 – Trabalhar usando dados
4 – Expor uma API Web
5 – Criar e implantar seu aplicativo ASP.NET Core no Azure
Aprender a usar o Visual Studio
Executar um programa
Abrir um projeto de um repositório
Escrever e editar o código
Compilação e construção
Depurar seu código
Teste de unidade
Implante o seu projeto
Acessar dados
Bem-vindo ao IDE do Visual Studio | C#
23/03/2020 • 30 minutes to read • Edit Online
O ambiente de desenvolvimento integrado do Visual Studio é um painel de inicialização criativo que você pode
usar para editar, depurar e compilar o código e, em seguida, publicar um aplicativo. Um IDE (ambiente de
desenvolvimento integrado) é um programa repleto de recursos que pode ser usado por muitos aspectos do
desenvolvimento de software. Além do editor e do depurador padrão fornecidos pela maioria dos IDEs, o Visual
Studio inclui compiladores, ferramentas de preenchimento de código, designers gráficos e muitos outros recursos
para facilitar o processo de desenvolvimento de software.
Esta imagem mostra o Visual Studio com um projeto aberto e várias importantes janelas de ferramentas que você
provavelmente usará:
O Gerenciador de Soluções (parte superior direita) permite exibir, navegar e gerenciar os arquivos de
código. O Solution Explorer pode ajudar a organizar seu código agrupando os arquivos em soluções e
projetos.
A janela do editor (parte central), na qual você provavelmente passará a maior parte do tempo, exibe o
conteúdo do arquivo. É nela em que você pode editar o código ou criar uma interface do usuário, como uma
janela com botões e caixas de texto.
A janela de Saída (parte central inferior) é o local em que o Visual Studio envia notificações, como mensagens
de erro e de depuração, avisos do compilador, mensagens de status da publicação e muito mais. Cada fonte de
mensagem tem uma guia própria.
O Team Explorer (canto inferior direito) permite que você acompanhe itens de trabalho e compartilhe o código
com outras pessoas usando tecnologias de controle de versão como o Git e o TFVC (Controle de Versão do
Team Foundation).
Edições
O Visual Studio está disponível para Windows e Mac. O Visual Studio para Mac tem muitas das mesmas
funcionalidades do Visual Studio 2017 e é otimizado para o desenvolvimento de aplicativos móveis e
multiplataforma. Este artigo concentra-se na versão do Visual Studio 2017 para Windows.
São três edições do Visual Studio: Community, Professional e Enterprise. Consulte Compare as edições do Visual
Studio para saber quais recursos são suportados em cada edição.
O Visual Studio está disponível para Windows e Mac. O Visual Studio para Mac tem muitas das mesmas
funcionalidades do Visual Studio 2019 e é otimizado para o desenvolvimento de aplicativos móveis e
multiplataforma. Este artigo concentra-se na versão do Visual Studio 2019 para Windows.
São três edições do Visual Studio 2019: Community, Professional e Enterprise. Consulte Compare as edições do
Visual Studio para saber quais recursos são suportados em cada edição.
Recursos de produtividade populares

Alguns dos recursos populares no Visual Studio que ajudam você a ser mais produtivo durante o desenvolvimento
de software incluem:
Rabiscos e Ações Rápidas
Rabiscos são sublinhados ondulados que alertam você sobre erros ou problemas potenciais no código
durante a digitação. Essas pistas visuais permitem que você corrija os problemas imediatamente sem
esperar que o erro seja descoberto durante o build ou quando você executar o programa. Se você focalizar
um rabisco, verá informações adicionais sobre o erro. Uma lâmpada também pode ser exibida na margem
esquerda com ações, conhecidas como Ações Rápidas, para corrigir o erro.
Limpeza de código
Com o clique de um botão, formate seu código e aplique quaisquer correções de código sugeridas por suas
configurações de estilo de código , convenções .editorconfig e analisadores Roslyn. A Limpeza de código
ajuda você a resolver problemas em seu código antes da transferência para revisão de código. (Disponível
apenas para código C# no momento.)
Refatoração
A refatoração inclui operações como renomeação inteligente de variáveis, extração de uma ou mais linhas
de código em um novo método, alteração da ordem dos parâmetros de método e muito mais.
IntelliSense
IntelliSense é um termo usado para um conjunto de recursos que exibe informações sobre o código
diretamente no editor e, em alguns casos, escreve pequenos trechos de código para você. É como ter a
documentação básica embutida no editor, o que evita que você tenha que consultar informações de tipo em
outro lugar. Os recursos do IntelliSense variam de acordo com a linguagem. Para saber mais, consulte C#
IntelliSense, Visual C++ IntelliSense, JavaScript IntelliSense e Visual Basic IntelliSense. A seguinte ilustração
mostra como o IntelliSense exibe uma lista de membros para um tipo:
Caixa de pesquisa
O Visual Studio pode parecer assustador, às vezes, com tantas propriedades, opções e menus. A caixa de
pesquisa é uma ótima maneira de encontrar rapidamente o que você precisa no Visual Studio. Quando você
começa a digitar o nome de algo que está procurando, o Visual Studio lista resultados que levam você
exatamente para o local em que precisa ir. Caso você precise adicionar uma funcionalidade ao Visual Studio,
por exemplo, para adicionar suporte a outra linguagem de programação, a caixa de pesquisa fornecerá
resultados que abrem o Instalador do Visual Studio para instalar uma carga de trabalho ou um componente
individual.
TIP
Pressione Ctrl+Q como um atalho para a caixa de pesquisa.
Para obter mais informações, consulte Início Rápido.
Live Share
Edite e depure de maneira colaborativa com outras pessoas em tempo real, independentemente do tipo de
aplicativo ou linguagem de programação. Você pode compartilhar seu projeto atual de forma instantânea e
segura e, conforme necessário, compartilhar sessões de depuração, instâncias de terminal, aplicativos Web
do localhost, chamadas de voz e muito mais.
Hierarquia de chamadas
A janela Hierarquia de Chamadas mostra os métodos que chamam um método selecionado. Essas
podem ser informações úteis quando você está considerando alterar ou remover o método ou quando está
tentando rastrear um bug.
CodeLens
O CodeLens ajuda você a encontrar referências e alterações no código, bugs vinculados, itens de trabalho,
revisões de código e testes de unidade, tudo isso sem sair do editor.
Ir para Definição
O recurso Ir para Definição leva você diretamente para o local em que uma função ou um tipo está definido.
Definição de Peek
A janela Espiar Definição mostra a definição de um método ou um tipo sem, na verdade, abrir um arquivo
separado.
Instalar o IDE do Visual Studio
Nesta seção, você criará um projeto simples para experimentar algumas coisas que pode fazer com o Visual Studio.
Você vai usar o IntelliSense como auxílio de codificação, depurar um aplicativo para ver o valor de uma variável
durante a execução do programa e alterar o tema de cores.
Para começar, baixe o Visual Studio e instale-o no sistema. O instalador modular permite escolher e instalar cargas
de trabalho, que são grupos de recursos necessários para a linguagem de programação ou para a plataforma de
sua preferência. Para seguir as etapas de criação de um programa, selecione a carga de trabalho
Desenvolvimento multiplataforma do .NET Core durante a instalação.
Para começar, baixe o Visual Studio e instale-o no sistema. O instalador modular permite escolher e instalar cargas
de trabalho, que são grupos de recursos necessários para a linguagem de programação ou para a plataforma de
sua preferência. Para seguir as etapas de criação de um programa, selecione a carga de trabalho
Desenvolvimento multiplataforma do .NET Core durante a instalação.
Ao iniciar o Visual Studio pela primeira vez, como opção, você pode entrar usando sua conta Microsoft ou sua
conta corporativa ou de estudante.
Criar um programa
Vamos nos aprofundar e criar um programa simples.
1. Abra o Visual Studio.
2. Na barra de menu, escolha Arquivo > Novo > Projeto .
A caixa de diálogo Novo Projeto mostra vários modelos de projeto. Um modelo contém as configurações e
os arquivos básicos necessários para um tipo de projeto fornecido.
3. Escolha a categoria de modelo .NET Core em Visual C# e escolha o modelo Aplicativo de Console
(.NET Core) . Na caixa de texto Nome , digite HelloWorld e, em seguida, selecione o botão OK .
NOTE
Se você não vir a categoria .NET Core , será necessário instalar a carga de trabalho Desenvolvimento de
plataforma cruzada do .NET Core . Para fazer isso, escolha o link Abrir o Instalador do Visual Studio na parte
inferior esquerda da caixa de diálogo Novo Projeto . Depois que o Instalador do Visual Studio for aberto, role a tela
para baixo, selecione a carga de trabalho Desenvolvimento multiplataforma do .NET Core e, em seguida,
selecione Modificar .
O Visual Studio cria o projeto. É um aplicativo "Olá, Mundo" simples que chama o método
Console.WriteLine() para exibir a cadeia de caracteres literal "Olá, Mundo!" na janela do console (saída do
programa).
Logo em seguida, você deverá ver algo parecido com isto:
O código C# para o aplicativo é mostrado na janela do editor, que ocupa a maior parte do espaço. Observe
que o texto é colorizado automaticamente para indicar diferentes partes do código, como palavras-chave e
tipos. Além disso, pequenas linhas verticais tracejadas no código indicam a correspondência de chaves e os
números de linha ajudam a localizar o código posteriormente. Escolha os pequenos sinais de subtração
demarcados para recolher ou expandir blocos de código. Esse recurso de estrutura de tópicos do código
permite ocultar os códigos desnecessários, ajudando a minimizar a desordem na tela. Os arquivos de
projeto são listados no lado direito em uma janela chamada Gerenciador de Soluções .
Há outros menus e outras janelas de ferramentas disponíveis, mas por enquanto, vamos seguir em frente.
4. Agora, inicie o aplicativo. Você pode fazer isso escolhendo Iniciar Sem Depuração no menu Depurar na
barra de menus. Você também pode pressionar Ctrl +F5 .
O Visual Studio compila o aplicativo e uma janela do console é aberta com a mensagem Olá, Mundo! .
Agora você tem um aplicativo em execução.
5. Para fechar a janela do console, pressione qualquer tecla do teclado.

6. Vamos adicionar um código adicional ao aplicativo. Adicione o código C# a seguir antes da linha que diz
Console.WriteLine("Hello World!"); :
Console.WriteLine("\nWhat is your name?");

var name = Console.ReadLine();
Esse código exibe Qual é seu nome? na janela do console e, em seguida, aguarda até que o usuário insira
um texto seguido da tecla Enter .
7. Altere a linha que indica Console.WriteLine("Hello World!"); para o seguinte código:
Console.WriteLine($"\nHello {name}!");
8. Execute o aplicativo novamente, selecionando Depurar > Iniciar Sem Depuração ou pressionando
Ctrl +F5 .
O Visual Studio recompila o aplicativo e uma janela do console é aberta e solicita seu nome.
9. Insira seu nome na janela do console e pressione Enter .
10. Pressione qualquer tecla para fechar a janela do console e interromper o programa em execução.
A janela de início é exibida com várias opções para clonar um repositório, abrir um projeto recente ou criar
um projeto.
2. Escolha Criar um novo projeto .
A janela Criar um novo projeto é aberta e mostra diversos modelos de projeto. Um modelo contém as
configurações e os arquivos básicos necessários para um tipo de projeto fornecido.
3. Para localizar o modelo desejado, digite ou insira console do .net core na caixa de pesquisa. A lista de
modelos disponíveis é filtrada automaticamente com base nas palavras-chave que você inseriu. Você pode
filtrar ainda mais os resultados do modelo, escolhendo C# na lista suspensa Linguagem . Selecione o
modelo Aplicativo de Console (.NET Core) e, em seguida, escolha Avançar .
4. Na janela Configurar seu novo projeto , insira HelloWorld na caixa Nome do projeto . Como opção,
altere a localização do diretório dos arquivos de projeto e escolha Criar .
O Visual Studio cria o projeto. É um aplicativo "Olá, Mundo" simples que chama o método
Console.WriteLine() para exibir a cadeia de caracteres literal "Olá, Mundo!" na janela do console (saída do
programa).
Logo em seguida, você deverá ver algo parecido com isto:
O código C# para o aplicativo é mostrado na janela do editor, que ocupa a maior parte do espaço. Observe
que o texto é colorizado automaticamente para indicar diferentes partes do código, como palavras-chave e
tipos. Além disso, pequenas linhas verticais tracejadas no código indicam a correspondência de chaves e os
números de linha ajudam a localizar o código posteriormente. Escolha os pequenos sinais de subtração
demarcados para recolher ou expandir blocos de código. Esse recurso de estrutura de tópicos do código
permite ocultar os códigos desnecessários, ajudando a minimizar a desordem na tela. Os arquivos de
projeto são listados no lado direito em uma janela chamada Gerenciador de Soluções .
Há outros menus e outras janelas de ferramentas disponíveis, mas por enquanto, vamos seguir em frente.
5. Agora, inicie o aplicativo. Você pode fazer isso escolhendo Iniciar Sem Depuração no menu Depurar na
barra de menus. Você também pode pressionar Ctrl +F5 .
O Visual Studio compila o aplicativo e uma janela do console é aberta com a mensagem Olá, Mundo! .
Agora você tem um aplicativo em execução.
6. Para fechar a janela do console, pressione qualquer tecla do teclado.

7. Vamos adicionar um código adicional ao aplicativo. Adicione o código C# a seguir antes da linha que diz
Console.WriteLine("Hello World!"); :
Console.WriteLine("\nWhat is your name?");

var name = Console.ReadLine();
Esse código exibe Qual é seu nome? na janela do console e, em seguida, aguarda até que o usuário insira
um texto seguido da tecla Enter .
8. Altere a linha que indica Console.WriteLine("Hello World!"); para o seguinte código:
Console.WriteLine($"\nHello {name}!");
9. Execute o aplicativo novamente, selecionando Depurar > Iniciar Sem Depuração ou pressionando
Ctrl +F5 .
O Visual Studio recompila o aplicativo e uma janela do console é aberta e solicita seu nome.
10. Insira seu nome na janela do console e pressione Enter .
11. Pressione qualquer tecla para fechar a janela do console e interromper o programa em execução.
Usar a refatoração e o IntelliSense

Vamos examinar algumas das maneiras pelas quais a refatoração e o IntelliSense podem ajudar você a codificar
com mais eficiência.
Primeiro, vamos renomear a variável name :
1. Clique duas vezes na variável name para selecioná-la.
2. Digite o novo nome da variável, username .
Observe que uma caixa cinza é exibida ao redor da variável e uma lâmpada é exibida na margem.
3. Selecione o ícone de lâmpada para mostrar as Ações Rápidas disponíveis. Selecione Renomear 'name'
como 'username' .
A variável é renomeada no projeto, o que, em nosso caso, são apenas dois locais.
3. Selecione o ícone de lâmpada para mostrar as Ações Rápidas disponíveis. Selecione Renomear 'name'
como 'username' .
A variável é renomeada no projeto, o que, em nosso caso, são apenas dois locais.
4. Agora vamos dar uma olhada no IntelliSense. Abaixo da linha que mostra
Console.WriteLine($"\nHello {username}!"); , digite DateTime now = DateTime. .
Uma caixa exibe os membros da classe DateTime. Além disso, a descrição do membro atualmente
selecionado é exibida em uma caixa separada.
5. Selecione o membro chamado Now , que é uma propriedade da classe, clicando duas vezes nele ou
pressionando Tab . Complete a linha de código adicionando um ponto e vírgula ao final.
6. Abaixo disso, digite ou cole as seguintes linhas de código:
int dayOfYear = now.DayOfYear;
Console.Write("Day of year: ");

Console.WriteLine(dayOfYear);
TIP
Console.Write é um pouco diferente de Console.WriteLine, pois não adiciona um terminador de linha após a
impressão. Isso significa que a próxima parte do texto que é enviada para a saída será impressa na mesma linha.
Focalize cada um desses métodos no código para ver a descrição.
7. Em seguida, usaremos a refatoração novamente para tornar o código um pouco mais conciso. Clique na
variável now na linha DateTime now = DateTime.Now; .
Observe que um pequeno ícone de chave de fenda é exibido na margem dessa linha.
8. Clique no ícone de chave de fenda para ver quais sugestões estão disponíveis no Visual Studio. Nesse caso,
está mostrando a refatoração Variável temporária embutida para remover uma linha de código sem alterar
o comportamento geral do código:
9. Clique em Variável temporária embutida para refatorar o código.
10. Execute o programa novamente pressionando Ctrl +F5 . A saída é semelhante ao seguinte:
10. Execute o programa novamente pressionando Ctrl +F5 . A saída é semelhante ao seguinte:
Depurar o código
Ao escrever o código, você precisa executá-lo e testá-lo para verificar se há bugs. O sistema de depuração do Visual
Studio permite que você execute em etapas uma instrução no código por vez e inspecione variáveis durante o
processo. Defina pontos de interrupção que interrompem a execução do código em uma linha específica. Observe
como o valor de uma variável é alterado durante a execução do código e muito mais.
Vamos definir um ponto de interrupção para ver o valor da variável username enquanto o programa está "em
andamento".
1. Encontre a linha de código que indica Console.WriteLine($"\nHello {username}!"); . Para definir um ponto de
interrupção nessa linha de código, ou seja, para fazer com que o programa pause a execução nessa linha,
clique na margem mais à esquerda do editor. Clique também em qualquer lugar na linha de código e, em
seguida, pressione F9 .
Um círculo vermelho é exibido na margem da extrema esquerda, e o código é realçado em vermelho.
2. Inicie a depuração selecionando Debug > Star t Debugging ou pressionando F5 .
3. Quando a janela do console for exibida e solicitar seu nome, digite-o e pressione Enter .
O foco retorna para o editor de códigos do Visual Studio e a linha de código com o ponto de interrupção é
realçada em amarelo. Isso significa que ela é a próxima linha de código que será executada pelo programa.
4. Passe o mouse sobre a variável username para ver seu valor. Como alternativa, clique com o botão direito
do mouse em username e selecione Adicionar Inspeção para adicionar a variável à janela Inspeção , na
qual você também pode ver o valor.
5. Para permitir que o programa seja executado até a conclusão, pressione F5 novamente.
Para obter mais detalhes sobre a depuração no Visual Studio, consulte Tour dos recursos do depurador.
Personalizar o Visual Studio

Personalize a interface do usuário do Visual Studio, incluindo a alteração do tema de cores padrão. Para alterar para
o tema Escuro :
1. Na barra de menus, escolha Opções de > ferramentas para abrir a caixa de diálogo Opções.
2. Na página de opções Ambiente > Geral , altere a seleção Tema de cores para Escuro e, em seguida,
escolha OK .
O tema de cores para todo o IDE é alterado para Escuro .
2. Na página de opções Ambiente > Geral , altere a seleção Tema de cores para Escuro e, em seguida,
escolha OK .
O tema de cores para todo o IDE é alterado para Escuro .
Para conhecer outras maneiras pelas quais você pode personalizar o IDE, confira Personalizar o Visual Studio.
Selecionar configurações do ambiente

Vamos configurar o Visual Studio para usar configurações de ambiente adequadas aos desenvolvedores em C#.
1. Na barra de menus, escolhaConfigurações de impor tação e expor tação de ferramentas > .
2. No Assistente de Impor tação e Expor tação de Configurações , selecione Redefinir todas as
configurações na primeira página e, em seguida, escolha Avançar .
3. Na página Salvar Configurações Atuais , selecione uma opção para salvar suas configurações atuais ou
não e, em seguida, escolha Avançar . Se você ainda não personalizou as configurações, selecione Não,
apenas redefina as configurações, substituindo minhas configurações atuais .
4. Na página Escolher uma Coleção Padrão de Configurações , escolha Visual C# e, em seguida, escolha
Concluir .
5. Na página Redefinição Concluída , escolha Fechar .
Para conhecer outras maneiras pelas quais você pode personalizar o IDE, confira Personalizar o Visual Studio.
Próximas etapas
Explore ainda mais o Visual Studio seguindo um dos seguintes artigos introdutórios:
Saiba como usar o editor de códigos
Saiba mais sobre projetos e soluções
Confira também
Descubra mais recursos do Visual Studio
Visite visualstudio.microsoft.com
Leia The Visual Studio blog (O blog do Visual Studio)
Nesta introdução de 10 minutos ao editor de código do Visual Studio, adicionaremos o código a um arquivo para
ver algumas das formas pelas quais o Visual Studio facilita a escrita, a navegação e o entendimento do código.
TIP
Se você ainda não instalou o Visual Studio, vá para a página de downloads do Visual Studio para instalá-lo gratuitamente.
TIP
Este artigo pressupõe que você já esteja familiarizado com o C#. Caso contrário, sugerimos que você primeiro
examine um tutorial, como Introdução ao C# e ao ASP.NET Core no Visual Studio.
TIP
Para acompanhar este artigo, verifique se você tem as configurações do C# selecionadas para o Visual Studio. Para obter
informações sobre como selecionar configurações para o IDE (ambiente de desenvolvimento integrado), confira Selecionar
configurações de ambiente.
Criar um novo arquivo de código

Comece criando um novo arquivo e adicionando códigos nele.
1. Abra o Visual Studio. Pressione Esc ou clique em Continuar sem código na janela de início para abrir o
ambiente de desenvolvimento.
2. No menu Arquivo na barra de menu, escolha Arquivo Novo > ou pressione Ctrl +N .
3. Na caixa de diálogo Novo Arquivo , na categoria Geral , escolha Classe do Visual C# e, então, selecione
Abrir .
Um novo arquivo é aberto no editor com o esqueleto de uma classe de C#. (Observe que não precisamos
criar um projeto completo do Visual Studio para obter alguns dos benefícios que o editor de códigos oferece;
basta ter um arquivo de código!)
Usar snippets de código
O Visual Studio fornece snippets de código úteis que você pode usar para gerar os blocos de código usados com
frequência de forma rápida e fácil. Os snippets de código estão disponíveis para linguagens de programação
diferentes, incluindo C#, Visual Basic e C++. Vamos adicionar o snippet void Main de C# em nosso arquivo.
1. Coloque o cursor logo acima } da cinta de fechamento svm final } static void Main —no arquivo e digite os
caracteres (o que significa não se preocupe muito se você não sabe o que isso significa).
Uma caixa de diálogo pop-up é exibida com informações sobre o snippet de código svm .
2. Pressione a Guia duas vezes para inserir o snippet de código.

Você verá que a assinatura do método static void Main() será adicionada ao arquivo. O método Main() é o
ponto de entrada para aplicativos C#.
Os snippets de código disponíveis variam em linguagens de programação diferentes. Você pode olhar os trechos de
código disponíveis para o seu idioma escolhendo Editar > intesteja > o Snippet ou pressionando Ctrl +K ,
Ctrl +X e, em seguida, escolhendo a pasta do seu idioma. Para o C#, a lista tem este aspecto:
A lista inclui snippets para a criação de uma classe, um construtor, um loop for, uma instrução if ou switch e muito
mais.
Comentar o código
A barra de ferramentas, que é a linha de botões sob a barra de menus no Visual Studio, pode ajudar a aumentar sua
produtividade durante a codificação. Por exemplo, você pode alternar o modo de preenchimento do IntelliSense (o
IntelliSense é um recurso de codificação que exibe uma lista de correspondência de métodos, entre outras coisas),
aumentar ou diminuir um recuo de linha ou comentar um código que você não deseja compilar. Nesta seção,
comentaremos alguns códigos.
1. Cole o código a seguir no corpo do método Main() .
// _words is a string array that we'll sort alphabetically

string[] _words = {
"the",
"quick",
"brown",
"fox",
"jumps"
};
string[] morewords = {
"over",
"the",
"lazy",
"dog"
};
IEnumerable<string> query = from word in _words

orderby word.Length
select word;
2. Não estamos usando a variável morewords , mas podemos usá-la mais tarde. Portanto, não queremos excluí-
la por completo. Em vez disso, vamos comentar as linhas. Selecione a definição inteira de morewords até o
ponto e vírgula de fechamento e, em seguida, escolha o botão Comentar as linhas selecionadas na barra
de ferramentas. Se preferir usar o teclado, pressione Ctrl +K, Ctrl +C .
Os caracteres de comentários // de C# são adicionados ao início de cada linha selecionada para comentar
o código.
Recolher blocos de código

Não queremos ver o construtor vazio para Class1 que foi gerado. Portanto, para desobstruir nossa exibição do
código, vamos recolhê-la. Escolha a pequena caixa cinza com o sinal de subtração dentro da margem da primeira
linha do construtor. Ou, se você é um usuário de teclado, coloque o cursor em qualquer lugar no código do
construtor e pressione Ctrl +M , Ctrl +M .
O bloco de código é recolhido apenas na primeira linha, seguido por um sinal de reticências ( ... ). Para expandir o
bloco de código novamente, clique na mesma caixa cinza que agora tem um sinal de mais nele, ou pressione
Ctrl +M , Ctrl +M novamente. Este recurso é chamado de Delineamento e é especialmente útil quando você está
colapsando métodos longos ou classes inteiras.
Exibir definições de símbolo

O editor do Visual Studio facilita a inspeção da definição de um tipo, método, etc. Uma maneira é navegar até o
arquivo que contém a definição, por exemplo, escolhendo Ir para Definição ou pressionando F12 em qualquer
lugar que o símbolo seja referenciado. Uma maneira ainda mais rápida que não move o foco para fora do arquivo
em que você está trabalhando é usar a opção Inspecionar Definição. Vamos espiar a definição do tipo string .
1. Clique com o botão direito do mouse em qualquer ocorrência de string e escolha Espiar Definição no
menu de conteúdo. Ou, pressione Alt +F12 .
Uma janela pop-up será exibida com a definição da classe String . Você pode rolar na janela pop-up ou até
mesmo inspecionar a definição de outro tipo do código inspecionado.
2. Feche a janela de definição inspecionada ao selecionar a caixa pequena com um “x” no canto superior direito
da janela pop-up.
Usar o IntelliSense para completar palavras

O IntelliSense é um recurso inestimável quando você está codificando. Ele pode mostrar informações sobre
membros disponíveis de um tipo ou detalhes de parâmetros para sobrecargas diferentes de um método. Você
também pode usar o IntelliSense para completar uma palavra depois que você digitar caracteres suficientes para
desambiguá-la. Vamos adicionar uma linha de código para imprimir as cadeias de caracteres ordenadas na janela
de console, que é o local padrão para envio da saída do programa.
1. Abaixo da variável query , comece a digitar o código a seguir:
foreach (string str in qu
Você verá o IntelliSense mostrar as Informações Rápidas sobre o símbolo query .
2. Para inserir o restante da palavra query usando a funcionalidade de preenchimento de palavras do

IntelliSense, pressione Tab .
3. Finalize o bloco de código para que ele se pareça com o seguinte código. Você mesmo pode praticar usando
os snippets de código novamente ao inserir cw e, então, pressionar a Guia duas vezes para gerar o código
Console.WriteLine .
foreach (string str in query)

{
Console.WriteLine(str);
}
Refatorar um nome
Ninguém obtém o código correto na primeira vez e uma das coisas que talvez você precise alterar é o nome de
uma variável ou de um método. Vamos experimentar a funcionalidade de refatorar do Visual Studio para renomear
a variável _words como words .
1. Coloque o cursor sobre _words a definição da variável e escolha Renomear no menu de clique siou ou
contexto, ou pressione Ctrl +R, Ctrl +R .
Uma caixa de diálogo pop-up chamada Renomear aparecerá no canto superior direito do editor.
2. Insira o nome desejado words . Observe que a referência ao words na consulta também será renomeada
automaticamente. Antes de pressionar Enter , marque a caixa de seleção Incluir Comentários na caixa pop-
up Renomear .
3. Pressione Enter .
As duas ocorrências de words foram renomeadas, bem como a referência ao words do comentário de
código.
Próximas etapas
Confira também
Snippets de código
Navegue pelos códigos
Estrutura de tópicos
Ir para Definição e Definição de Pico
Refatoração
Usar o IntelliSense
Neste artigo introdutório, exploraremos o que significa criar uma solução e um projeto no Visual Studio. Uma
solução é um contêiner usado para organizar um ou mais projetos de código relacionados, por exemplo, um
projeto de biblioteca de classes e um projeto de teste correspondente. Vamos examinar as propriedades de um
projeto e alguns dos arquivos que ele pode conter. Também criaremos uma referência de um projeto a outro.
Se você ainda não instalou o Visual Studio, vá para a página de downloads do Visual Studio para instalá-lo
gratuitamente.
gratuitamente.
Desenvolveremos uma solução e um projeto do zero como um exercício educacional para compreendermos o
conceito de um projeto. Em seu uso geral do Visual Studio, você provavelmente usará alguns dos vários modelos
de projeto oferecidos pelo Visual Studio quando estiver criando um projeto.
NOTE
As soluções e os projetos não precisam desenvolver aplicativos no Visual Studio. Você também pode apenas abrir uma pasta
que contém o código e começar a codificar, compilar e depurar. Por exemplo, se você clonar um repo do GitHub, ele pode
não conter projetos e soluções do Visual Studio. Para obter mais informações, consulte Desenvolver código no Visual Studio
sem projetos nem soluções.
Soluções e projetos
Apesar do nome, uma solução não é uma "resposta". Uma solução é apenas um contêiner usado pelo Visual
Studio para organizar um ou mais projetos relacionados. Quando você abre uma solução no Visual Studio, ele
carrega automaticamente todos os projetos que a solução contém.
Criar uma solução
Vamos iniciar nossa exploração criando uma solução vazia. Depois de se familiarizar com o Visual Studio,
provavelmente, você não precisará criar soluções vazias com muita frequência. Quando você cria um projeto, o
Visual Studio cria automaticamente uma solução para hospedar o projeto, caso não haja uma solução já aberta.
2. Na barra de menus superior, escolha Arquivo > Novo > Projeto .
A caixa de diálogo Novo Projeto será aberta.
3. No painel esquerdo, expanda a opção Outros Tipos de Projetos e, então, selecione Soluções do Visual
Studio . No painel central, escolha o modelo Solução em Branco . Nomeie a solução QuickSolution e,
em seguida, escolha o botão OK .
A Página Inicial é fechada e uma solução é exibida no Gerenciador de Soluções do lado direito da
janela do Visual Studio. Você provavelmente usará o Gerenciador de Soluções muitas vezes para
navegar pelo conteúdo de seus projetos.
2. Na janela inicial, escolha Criar um novo projeto .
3. Na página Criar um novo projeto , insira solução em branco na caixa de pesquisa, selecione o modelo
Solução em Branco e escolha Avançar .
4. Nomeie a solução como QuickSolution e escolha Criar .

A solução aparece no Gerenciador de Soluções do lado direito da janela do Visual Studio. Você
provavelmente usará o Gerenciador de Soluções muitas vezes para navegar pelo conteúdo de seus
projetos.
Adicionar um projeto
Agora vamos adicionar nosso primeiro projeto à solução. Vamos começar com um projeto vazio e adicionar os
itens necessários ao projeto.
1. Ao clicar com o botão direito do mouse ou no menu de contexto da Solução ‘QuickSolution’ no
Gerenciador de Soluções , escolha Adicionar > Novo Projeto .
A caixa de diálogo Adicionar Novo Projeto é aberta.
2. No painel esquerdo, expanda Visual C# e escolha Área de Trabalho do Windows . Em seguida, no
painel central, selecione o modelo Projeto Vazio (.NET Framework) . Nomeie o projeto QuickDate e, em
seguida, escolha OK .
Um projeto chamado QuickDate aparece abaixo da solução no Solution Explorer . Atualmente, ele contém
um único arquivo chamado App.config.
NOTE
Se você não ver Visual C# no painel esquerdo da caixa de diálogo, você deve instalar a carga de trabalho do Visual
Studio. O Visual Studio usa instalação baseada em carga de trabalho para instalar apenas os componentes
necessários para o tipo de desenvolvimento que você faz. Uma maneira fácil de instalar uma nova carga de trabalho
é escolher o link Abrir Instalador do Visual Studio no canto inferior esquerdo da caixa de diálogo Adicionar
Novo Projeto . Após o início do Instalador do Visual Studio, escolha a carga de trabalho Desenvolvimento para
área de trabalho em .NET e, em seguida, o botão Modificar .

Uma caixa de diálogo é aberta com o título Adicionar um novo projeto .
2. Insira o texto vazio na caixa de pesquisa na parte superior e, em seguida, selecione C# em Idioma .
3. Selecione o modelo Projeto Vazio (.NET Framework) e, em seguida, Avançar .
4. Nomeie o projeto QuickDate e, em seguida, escolha Criar .
Um projeto chamado QuickDate aparece abaixo da solução no Solution Explorer . Atualmente, ele contém
um único arquivo chamado App.config.
NOTE
Se você não ver o modelo Empty Project (.NET Framework), você deve instalar a carga de trabalho do Visual
Studio. O Visual Studio usa instalação baseada em carga de trabalho para instalar apenas os componentes
necessários para o tipo de desenvolvimento que você faz. Uma maneira fácil de instalar uma nova carga de trabalho
ao criar um projeto é escolher o link Instalar mais ferramentas e recursos no texto que informa Não encontra
o que você está procurando? . Após o início do Instalador do Visual Studio, escolha a carga de trabalho
Desenvolvimento para área de trabalho em .NET e, em seguida, o botão Modificar .
Adicionar um item ao projeto

Temos um projeto vazio. Vamos adicionar um arquivo de código.
1. No menu de clique com o botão direito do mouse ou de contexto do projeto QuickDate no Gerenciador
de Soluções , escolha Adicionar > Novo Item .
A caixa de diálogo Adicionar Novo Item é aberta.
2. Expanda a opção Itens do Visual C# e, em seguida, escolha Código . No painel do meio, escolha o
modelo de item classe. Nomeie o calendário da classe e escolha o botão Adicionar.
Um arquivo chamado Calendar.cs é adicionado ao projeto. O .cs no final é a extensão de arquivo que é
fornecida aos arquivos de código C#. O arquivo é exibido na hierarquia do projeto visual no Gerenciador
de Soluções e seu conteúdo é aberto no editor.
3. Substitua o conteúdo do arquivo Calendar.cs pelo seguinte código:
using System;
namespace QuickDate
{
internal class Calendar
{
static void Main(string[] args)
{
DateTime now = GetCurrentDate();
Console.WriteLine($"Today's date is {now}");
Console.ReadLine();
}
internal static DateTime GetCurrentDate()

{
return DateTime.Now.Date;
}
}
}
Você não precisa entender o que o código faz, mas se você quiser, você pode executar o programa
pressionando Ctrl +F5 e ver se ele imprime a data de hoje para a janela do console (ou saída padrão).
Adicionar um segundo projeto

É comum que as soluções contenham mais de um projeto e que, geralmente, esses projetos façam referência uns
aos outros. Alguns projetos em uma solução podem ser bibliotecas de classes, alguns aplicativos executáveis e
outros podem ser projetos de teste de unidade ou sites.
Vamos adicionar um projeto de teste de unidade em nossa solução. Desta vez, começaremos com um modelo de
projeto, de modo que não precisemos adicionar outro arquivo de código ao projeto.
2. No painel esquerdo, expanda Visual C# e escolha a categoria Teste . No painel central, escolha o modelo
de projeto Projeto de Teste MSTest (.NET Core) . Nomeie o projeto QuickTest e escolha OK .
Um segundo projeto é adicionado ao Gerenciador de Soluções e um arquivo chamado UnitTest1.cs é
aberto no editor.
2. Na caixa de diálogo Adicionar um novo projeto , insira o texto teste de unidade na caixa de pesquisa
na parte superior e, em seguida, selecione C# em Idioma .
3. Escolha o modelo de projeto Projeto de Teste MSTest (.NET Core) e escolha Avançar .
4. Nomeie o projeto QuickTest e escolha Criar .
Um segundo projeto é adicionado ao Gerenciador de Soluções e um arquivo chamado UnitTest1.cs é
aberto no editor.
Adicionar uma referência ao projeto

Vamos usar o novo projeto de teste de unidade para testar nosso método no projeto QuickDate . Portanto,
precisamos adicionar uma referência a esse projeto. Isso cria uma dependência de build entre os dois projetos, o
que significa que quando a solução é criada, QuickDate é criado antes dependência QuickTest .
1. Escolha o nó Dependências no projeto QuickTest e, ao clicar com o botão direito do mouse ou no menu
de contexto, escolha Adicionar Referência .
A caixa de diálogo Gerenciador de Referências é aberta.
2. No painel esquerdo, expanda Projetos e escolha Solução . No painel do meio, escolha a caixa de seleção
ao lado de QuickDate e escolha OK .
Uma referência ao projeto QuickDate será adicionada.
Adicionar código de teste

1. Agora, adicionaremos o código de teste ao arquivo de código de teste C#. Substitua o conteúdo do
UnitTest1.cs pelo seguinte código:
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace QuickTest
{
[TestClass]
public class UnitTest1
{
[TestMethod]
public void TestGetCurrentDate()
{
Assert.AreEqual(DateTime.Now.Date, QuickDate.Calendar.GetCurrentDate());
}
}
}
Você verá uma linha sinuosa vermelha em alguns dos códigos. Nós corrigiremos esse erro ao tornar o
projeto de teste um assembly amigável para o projeto QuickDate .
2. De volta ao projeto QuickDate , abra o arquivo Calendar.cs se ele ainda não estiver aberto. Adicione a
instrução using a seguir e o atributo InternalsVisibleToAttribute à parte superior do arquivo, para resolver o
erro no projeto de teste.
using System.Runtime.CompilerServices;
[assembly: InternalsVisibleTo("QuickTest")]
O arquivo de código deve ter esta aparência:
Propriedades do projeto
A linha no arquivo Calendar.cs que contém o atributo InternalsVisibleToAttribute referencia o nome do assembly
(nome de arquivo) do projeto QuickTest . O nome do assembly pode não ser sempre o mesmo que o nome do
projeto. Para localizar o nome do assembly de um projeto, abra as propriedades do projeto.
1. No Gerenciador de Soluções , selecione o projeto QuickTest . Ao clicar com o botão direito do mouse ou
no menu de contexto, selecione Propriedades ou pressione Alt +Enter .
As páginas de propriedade do projeto abrem na guia Aplicativo. As páginas de propriedade contêm várias
configurações para o projeto. Observe que o nome do assembly do projeto QuickTest é, de fato,
“QuickTest”. Caso deseje alterá-lo, este é o local em que você poderá fazer isso. Assim, quando você
compilar o projeto de teste, o nome do arquivo binário resultante será alterado de QuickTest.dll para o que
você escolher.
2. Explore algumas das outras guias das páginas de propriedades do projeto, como Build e Depurar . Essas
guias são diferentes para diferentes tipos de projetos.
Próximas etapas
Se você quiser verificar se o teste da unidade está funcionando, escolha Executar > Run > todos os testes na
barra de menu. Uma janela chamada Gerenciador de Testes será aberta e você verá que o teste
TestGetCurrentDate será aprovado.
TIP
Se o Gerenciador de Testes não abrir automaticamente, abra-o escolhendo Teste > Windows > Gerenciador de
Testes na barra de menus.
TIP
Se o Test Explorer não abrir automaticamente, abra-o escolhendo Test > Explorer na barra de menu.
Confira também
Criar projetos e soluções
Gerenciar propriedades de projetos e soluções
Gerenciar referências em um projeto
Desenvolver código no Visual Studio sem projetos nem soluções
Visão geral do IDE do Visual Studio
Funcionalidades do Visual Studio
O artigo Visão geral do IDE do Visual Studio fornece uma introdução básica ao Visual Studio. Este artigo descreve
os recursos que podem ser mais apropriados para desenvolvedores experientes ou aqueles que já estão
familiarizados com o Visual Studio.
Instalação modular
O instalador modular do Visual Studio permite que você escolha e instale cargas de trabalho. As cargas de trabalho
são grupos de recursos necessários para a linguagem de programação ou a plataforma de sua preferência. Essa
estratégia ajuda a manter a superfície de instalação do Visual Studio menor, o que significa que ele é instalado e
atualizado mais rapidamente também.
gratuitamente.
gratuitamente.
Para saber mais sobre como configurar o Visual Studio no sistema, confira Instalar o Visual Studio.
Criar aplicativos habilitados para a nuvem para o Azure

O Visual Studio oferece um pacote de ferramentas que permite criar aplicativos habilitados para a nuvem com
facilidade da plataforma Microsoft Azure. É possível configurar, compilar, depurar, empacotar e implantar
aplicativos e serviços no Microsoft Azure diretamente por meio do IDE. Para obter as ferramentas e modelos de
projeto do Azure, selecione a carga de trabalho Desenvolvimento do Azure ao instalar o Visual Studio.
Após instalar a carga de trabalho desenvolvimento do Azure , os seguintes modelos de nuvem para C# estarão
disponíveis na caixa de diálogo Novo Projeto :
O Cloud Explorer do Visual Studio permite exibir e gerenciar seus recursos de nuvem baseados no Azure dentro do
Visual Studio. Esses recursos podem incluir máquinas virtuais, tabelas, bancos de dados SQL e mais. O Cloud
Explorer mostra os recursos do Azure em todas as contas gerenciadas na assinatura do Azure à qual você está
conectado. E se uma operação específica exigir o portal do Azure, o Cloud Explorer fornecerá links que
direcionem você no portal para onde for necessário.
É possível utilizar os serviços do Azure para seus aplicativos usando os Ser viços Conectados como:
Serviço conectado do Active Directory para os usuários poderem usar suas contas no Azure Active Directory
para se conectar aos aplicativos Web
Serviço conectado do Armazenamento do Azure para armazenamento de blobs, filas e tabelas
Serviço conectado do Key Vault para gerenciar segredos para aplicativos Web
Os Ser viços Conectados disponíveis dependem de seu tipo de projeto. Adicione um serviço clicando com o
botão direito do mouse no projeto no Gerenciador de Soluções e escolhendo Adicionar > Ser viço
Conectado .
Para obter mais informações, confira Move to the cloud With Visual Studio and Azure (Mover para a nuvem com o
Visual Studio e o Azure).
Criar aplicativos para a Web

A Internet impulsiona nosso mundo moderno e o Visual Studio pode ajudá-lo a escrever aplicativos para ele. É
possível criar aplicativos Web usando ASP.NET, Node.js, Python, JavaScript e TypeScript. O Visual Studio reconhece
estruturas Web como Angular, jQuery, Express e muito mais. O ASP.NET Core e o .NET Core são executados nos
sistemas operacionais Windows, Mac e Linux. O ASP.NET Core é uma atualização importante para MVC, WebAPI e
SignalR e é executado no Windows, no Mac e no Linux. O ASP.NET Core foi projetado desde o princípio para
fornecer a você uma pilha .NET enxuta e combinável para compilar serviços e aplicativos Web modernos baseados
em nuvem.
Para obter mais informações, consulte Ferramentas da Web modernas.
Criar jogos e aplicativos de plataforma cruzada

É possível usar o Visual Studio para compilar aplicativos e jogos para macOS, Linux e Windows, bem como para
Android, iOS e outros dispositivos móveis.
Crie aplicativos .NET Core executados em Windows, macOS e Linux.
Crie aplicativos móveis para iOS, Android e Windows em C# e F# usando o Xamarin.
Use tecnologias Web — HTML, CSS e JavaScript — padrão para criar aplicativos móveis para iOS, Android e
Windows usando o Apache Cordova.
Crie jogos 2D e 3D em C# usando Ferramentas do Visual Studio para Unity.
Compile aplicativos C++ nativos para dispositivos iOS, Android e Windows. Compartilhe código comum
em bibliotecas criadas para iOS, Android e Windows usando C++ para desenvolvimento multiplataforma.
Implante, teste e depure aplicativos Android com o Android Emulator.
Conectar-se aos bancos de dados

O Gerenciador de Ser vidores ajuda você a procurar e a gerenciar ativos e instâncias do SQL Server locais,
remotos e no Azure, no Salesforce.com, no Office 365 e em sites. Para abrir o Ser ver Explorer, no menu principal,
escolha Exibir > o Explorador do Ser vidor . Para obter mais informações de como usar o Gerenciador de
Servidores, confira Adicionar novas conexões.
O SSDT (SQL Server Data Tools) é um ambiente de desenvolvimento avançado do SQL Server, do Banco de Dados
SQL do Azure e do SQL Data Warehouse do Azure. Ele permite compilar, depurar, manter e refatorar bancos de
dados. Você pode trabalhar com um projeto de banco de dados ou diretamente com uma instância local ou não de
banco de dados conectado.
O Pesquisador de Objetos do SQL Ser ver no Visual Studio fornece uma exibição dos objetos de banco de
dados semelhante ao SQL Server Management Studio. O Pesquisador de Objetos do SQL Server permite que você
faça o trabalho leve de administração e design de banco de dados. Exemplos de trabalho incluem editar dados da
tabela, comparar esquemas, executar consultas usando menus contextuais diretamente do Pesquisador de Objetos
do SQL Server e muito mais.
Depurar, testar e melhorar o código

Quando você escrever o código, é necessário executá-lo e testá-lo para verificar o desempenho e se há bugs. O
sistema de depuração de última geração do Visual Studio permite depurar o código em execução no projeto local,
em um dispositivo remoto ou em um emulador de dispositivo. Você pode percorrer pelo código uma instrução por
vez e inspecionar as variáveis conforme avança. Você pode definir pontos de interrupção que são atingidos
somente quando uma determinada condição é verdadeira. As opções de depuração podem ser gerenciadas no
próprio editor de códigos, para que você não precise sair do código. Para obter mais detalhes sobre a depuração
no Visual Studio, confira Primeiro acesso ao depurador.
Para saber mais sobre como melhorar o desempenho de seus aplicativos, confira a funcionalidade de criação de
perfil do Visual Studio.
Para testes, o Visual Studio oferece teste de unidade, Live Unit Testing, IntelliTest, teste de desempenho e de carga e
muito mais. O Visual Studio também aprimorou as funcionalidades de análise de código para capturar o design,
segurança e outros tipos de falhas.
Implantar o aplicativo concluído

Quando o aplicativo estiver pronto para ser implantado em usuários ou clientes, o Visual Studio fornecerá as
ferramentas para fazer isso. As opções de implantação incluem na Microsoft Store, em um site do SharePoint ou
com as tecnologias InstallShield ou Windows Installer. Ele é todo acessível por meio do IDE. Para obter mais
informações, consulte Implantar aplicativos, serviços e componentes.
Gerenciar seu código-fonte e colaborar com outros

É possível gerenciar o código-fonte em repositórios Git hospedados por qualquer provedor, incluindo o GitHub. Ou
use o Azure DevOps Services para gerenciar o código, bem como bugs e itens de trabalho de todo o projeto.
Consulte Introdução ao GIT e ao Azure Repos para obter mais informações sobre o gerenciamento de repositórios
GIT no Visual Studio usando o Team Explorer. O Visual Studio também tem outros recursos de controle do código-
fonte internos. Para saber mais sobre eles, confira Novas funcionalidades do Git no Visual Studio (blog).
Os Azure DevOps Services são serviços baseados em nuvem para planejar, hospedar, automatizar e implantar o
software e habilitar a colaboração nas equipes. Os Azure DevOps Services dão suporte a repositórios Git (controle
de versão distribuído) e ao Controle de Versão do Team Foundation (controle de versão centralizado). Eles dão
suporte a pipelines de build e versão contínuos (CI/CD) de código armazenado em sistemas de controle de versão.
O Azure DevOps Services também dá suporte a metodologias de desenvolvimento Agile, CMMI e Scrum.
O TFS (Team Foundation Server) é o hub de gerenciamento do ciclo de vida do aplicativo para o Visual Studio. Ele
habilita a participação de todos os envolvidos com o processo de desenvolvimento usando uma única solução. O
TFS também é útil para gerenciar equipes e projetos heterogêneos.
Se você tiver uma organização do Azure DevOps ou um Team Foundation Server na rede, conecte-se a ela por
meio da janela Team Explorer no Visual Studio. Nessa janela você pode fazer check-in ou check-out de código no
controle do código-fonte, gerenciar itens de trabalho, iniciar compilações e acessar salas da equipe e workspaces.
Abra o Team Explorer na caixa de pesquisa ou no menu principal, em Exibir > Team Explorer ou em Equipe >
Gerenciar Conexões .
A imagem a seguir mostra a janela Team Explorer em uma solução hospedada no Azure DevOps Services.
Também é possível automatizar o processo de build para compilar o código que os desenvolvedores de sua equipe
fizeram check-in no controle de versão. Por exemplo, será possível criar um ou mais projetos à noite ou sempre
que o check-in do código for feito. Para obter mais informações, confira Azure Pipelines.
Estenda o Visual Studio

Se o Visual Studio não tiver a funcionalidade exata de que você precisa, será possível adicioná-la! É possível
personalizar o IDE de acordo com o estilo e fluxo de trabalho, adicionar suporte para ferramentas externas que
ainda não estão integradas ao Visual Studio e modificar a funcionalidade existente para aumentar a produtividade.
Para encontrar a versão mais recente das Ferramentas de Extensibilidade do Visual Studio (SDK do VS), confira
Visual Studio SDK (SDK do Visual Studio).
Você pode usar o .NET Compiler Platform ("Roslyn") para escrever seus próprios analisadores de código e
geradores de código. Encontre tudo o que você precisa em Roslyn.
Encontre extensões existentes para o Visual Studio criadas pelos desenvolvedores da Microsoft, bem como pela
nossa comunidade de desenvolvimento.
Para saber mais sobre como estender o Visual Studio, consulte Estender o IDE do Visual Studio.
Confira também
Visão geral do IDE do Visual Studio
Novidades no Visual Studio 2017
Novidades do Visual Studio 2019
Tutorial: Crie um aplicativo de console C# simples no
Visual Studio
Neste tutorial do C#, você usará o Visual Studio para criar e executar um aplicativo de console e explorar alguns
recursos do IDE (ambiente de desenvolvimento integrado) do Visual Studio durante esse processo.
gratuitamente.
gratuitamente.
Criar um projeto
Para começar, criaremos um projeto de aplicativo em C#. O tipo de projeto inclui todos os arquivos de modelo que
você precisará, mesmo sem adicionar nada!
1. Abra o Visual Studio 2017.
2. Na barra de menu superior, escolha Arquivo > Novo > Projeto . (Alternativamente, pressione
Ctrl +Shift +N ).
3. No painel esquerdo da caixa de diálogo Novo Projeto , expanda C# e, em seguida, escolha .NET Core . No
painel central, escolha Aplicativo de Console (.NET Core) . Em seguida, nomeie o arquivo como
Calculator .
Adicionar uma carga de trabalho (opcional)

Se o modelo de projeto Aplicativo do Console (.NET Core) não for exibido, você poderá obtê-lo adicionando a
carga de trabalho Desenvolvimento .NET Core de multiplataforma . Veja como.
Opção 1: usar a caixa de diálogo Novo Projeto
1. Selecione o link Abrir o Instalador do Visual Studio no painel esquerdo da caixa de diálogo Novo
Projeto .
2. O Instalador do Visual Studio é iniciado. Escolha a carga de trabalho Desenvolvimento multiplaforma do

.NET Core e, em seguida, selecione Modificar .
Opção 2: usar a barra de menus Ferramentas

1. Cancele a caixa de diálogo Novo Projeto ; em seguida, vá até a barra de menus superior e escolha
Ferramentas > Obter Ferramentas e Recursos .
2. O Instalador do Visual Studio é iniciado. Escolha a carga de trabalho Desenvolvimento multiplaforma do
.NET Core e, em seguida, selecione Modificar .
3. Na janela Criar um novo projeto , insira ou digite console na caixa de pesquisa. Em seguida, escolha C# na
lista Linguagem de programação e, em seguida, escolha Windows na lista Plataforma.
Depois de aplicar os filtros de linguagem de programação e plataforma, escolha o modelo Aplicativo de
Console (.NET Core) e, em seguida, escolha Avançar .
NOTE
Se não vir o modelo Aplicativo de Console (.NET Core) , você poderá instalá-lo da janela Criar um novo
projeto . Na mensagem Não encontrou o que precisa? , escolha o link Instalar mais ferramentas e recursos .
Em seguida, no Instalador do Visual Studio, escolha a carga de trabalho de desenvolvimento multiplataforma do

.NET Core .
Depois disso, escolha o botão Modificar no Instalador do Visual Studio. Pode ser solicitado que você salve seu
trabalho; nesse caso, faça isso. Em seguida, escolha Continuar para instalar a carga de trabalho. Em seguida, retorne
para a etapa 2 deste procedimento para "Criar um projeto".
4. Na janela Configurar seu novo projeto , digite ou insira Calculadora na caixa Nome do projeto . Em
seguida, escolha Criar .
O Visual Studio abre seu novo projeto, que inclui o código "Olá, Mundo" padrão.
Criar o aplicativo
Primeiro, exploraremos os cálculos matemáticos básicos de inteiro em C#. Em seguida, adicionaremos o código
para criar uma calculadora básica. Depois disso, depuraremos o aplicativo para encontrar e corrigir erros. E, por
fim, refinaremos o código para torná-lo mais eficiente.
Explorar a matemática de inteiros
Vamos começar com alguns cálculos matemáticos básicos de inteiro em C#.
1. No editor de códigos, exclua o código padrão "Olá, Mundo".
Especificamente, exclua a linha com o texto: Console.WriteLine("Hello World!"); .

2. Em seu lugar, digite o seguinte código:
int a = 42;
int b = 119;
int c = a + b;
Console.WriteLine(c);
Console.ReadKey();
Observe que quando você faz isso, o recurso IntelliSense no Visual Studio oferece a opção de preencher
automaticamente a entrada.
NOTE
A animação a seguir não pretende duplicar o código anterior. Destina-se apenas a mostrar como o recurso de
autocompletar funciona.
3. Escolha o botão verde Iniciar ao lado da Calculadora para construir e executar o seu programa, ou
pressione F5 .
Uma janela do console é aberta mostrando a soma de 42 + 119, que é 161 .

4. (Opcional) Você pode alterar o operador para alterar o resultado. Por exemplo, você pode alterar o
operador + na linha de código int c = a + b; para - em uma subtração, * para multiplicação ou /
para divisão. Em seguida, quando você executar o programa, o resultado também será alterado.
5. Feche a janela do console.
Adicionar código para criar uma calculadora
Vamos continuar com a adição de um conjunto mais complexo de código de calculadora ao seu projeto.
1. Exclua todo o código exibido no editor de códigos.
2. Insira ou cole o seguinte novo código no editor de códigos:
using System;
namespace Calculator
{
class Program
{
{
// Declare variables and then initialize to zero.
int num1 = 0; int num2 = 0;
// Display title as the C# console calculator app.

Console.WriteLine("Console Calculator in C#\r");
Console.WriteLine("------------------------\n");
// Ask the user to type the first number.

Console.WriteLine("Type a number, and then press Enter");
num1 = Convert.ToInt32(Console.ReadLine());
// Ask the user to type the second number.

Console.WriteLine("Type another number, and then press Enter");
// Ask the user to choose an option.

Console.WriteLine("Choose an option from the following list:");
Console.WriteLine("\ta - Add");
Console.WriteLine("\ts - Subtract");
Console.WriteLine("\tm - Multiply");
Console.WriteLine("\td - Divide");
Console.Write("Your option? ");
// Use a switch statement to do the math.

switch (Console.ReadLine())
{
case "a":
Console.WriteLine($"Your result: {num1} + {num2} = " + (num1 + num2));
break;
case "s":
Console.WriteLine($"Your result: {num1} - {num2} = " + (num1 - num2));
break;
case "m":
Console.WriteLine($"Your result: {num1} * {num2} = " + (num1 * num2));
break;
case "d":
Console.WriteLine($"Your result: {num1} / {num2} = " + (num1 / num2));
break;
}
// Wait for the user to respond before closing.
Console.Write("Press any key to close the Calculator console app...");
Console.ReadKey();
}
}
}
3. Escolha Calculadora para executar seu programa ou pressione F5 .
Uma janela do console é aberta.

4. Exiba o aplicativo na janela do console e, em seguida, siga os prompts para adicionar os números 42 e 119 .
O aplicativo deverá ser semelhante à seguinte captura de tela:
Adicionar funcionalidade à calculadora
Ajustaremos o código para adicionar mais funcionalidade.
Adicionar decimais
Atualmente, o aplicativo de calculadora aceita e retorna números inteiros. No entanto, ele será mais preciso se
adicionarmos um código que permita decimais.
Como mostrado na captura de tela a seguir, se você executar o aplicativo e dividir o número 42 pelo número 119, o
resultado será 0 (zero), o que não é exato.
Vamos corrigir o código para que ele identifique decimais.

1. Pressione Ctrl + F para abrir o controle Encontrar e Substituir.
2. Altere cada instância da variável int para float .
Verifique se ativou/desativou as opções Diferenciar maiúsculas de minúsculas (Alt +C ) e Coincidir
palavra inteira (Alt +W ) no controle Localizar e substituir .
3. Execute novamente o aplicativo de calculadora e divida o número 42 pelo número 119 .

Observe que o aplicativo agora retorna um numeral decimal em vez de zero.
No entanto, o aplicativo produz apenas um resultado decimal. Vamos fazer mais alguns ajustes no código, de
modo que o aplicativo possa calcular decimais também.
1. Use o controle Localizar e Substituir (Ctrl + F ) para alterar cada instância da variável float para double
e alterar cada instância do método Convert.ToInt32 para Convert.ToDouble .
2. Execute o aplicativo de calculadora e divida o número 42,5 pelo número 119,75 .
Observe que o aplicativo agora aceita valores decimais e retorna um numeral decimal mais longo como
resultado.
(Corrigiremos o número de casas decimais na seção Revisar o código.)
Depurar o aplicativo
Melhoramos nosso aplicativo de calculadora básica, mas ele ainda não é à prova de falhas para tratar exceções,
como erros de entrada do usuário.
Por exemplo, se você tentar dividir um número por zero ou digitar um caractere alfa quando o aplicativo espera um
caractere numérico (ou vice-versa), o aplicativo pode parar de funcionar, retornar um erro ou retornar um
resultado não numérico inesperado.
Vamos passar por alguns erros comuns de entrada do usuário, localizá-los no depurador se eles aparecerem lá e
corrigi-los no código.
TIP
Para obter mais informações sobre o depurador e como ele funciona, confira a página Introdução ao depurador do Visual
Studio.
Corrigir o erro de "divisão por zero"

Quando você tenta dividir um número por zero, o aplicativo do console pode congelar e, em seguida, mostrar o
que está errado no editor de código.
NOTE
Às vezes, o aplicativo não congela e o depurador não mostra um erro de divisão por zero. Em vez disso, o aplicativo pode
retornar um resultado não numérico inesperado, como um símbolo infinito. A seguinte correção de código ainda se aplica.
Vamos alterar o código para tratar esse erro.

1. Exclua o código exibido diretamente entre case "d": e o comentário
// Wait for the user to respond before closing .
2. Substitua-o pelo seguinte código:
// Ask the user to enter a non-zero divisor until they do so.

while (num2 == 0)
{
Console.WriteLine("Enter a non-zero divisor: ");
}
Console.WriteLine($"Your result: {num1} / {num2} = " + (num1 / num2));
break;
}
Depois que você adicionar o código, a seção com a instrução switch deverá ser semelhante à seguinte
captura de tela:
Agora, quando você dividir qualquer número por zero, o aplicativo solicitará outro número. Melhor ainda: ele não
vai parar de perguntar até que você forneça um número diferente de zero.
Corrigir o erro de "formato"

Se você inserir um caractere alfa quando o aplicativo esperar um caractere numérico (ou vice-versa), o aplicativo
de console congelará. Em seguida, o Visual Studio mostra o que há de errado no editor de códigos.
Para corrigir esse erro, precisamos refatorar o código que inserimos anteriormente.
Revisar o código
Em vez de depender da classe program para tratar todo o código, dividiremos nosso aplicativo em duas classes:
Calculator e Program .
A classe Calculator fará a maior parte do trabalho de cálculo e a classe Program cuidará do trabalho de captura
de erros e da interface do usuário.
Vamos começar.
1. Exclua tudo Calculator no namespace entre suas chaves de abertura e fechamento:
using System;
{
2. Depois, adicione uma nova classe Calculator , da seguinte maneira:

class Calculator
{
public static double DoOperation(double num1, double num2, string op)
{
double result = double.NaN; // Default value is "not-a-number" which we use if an operation,
such as division, could result in an error.

switch (op)
{
case "a":
result = num1 + num2;
break;
case "s":
result = num1 - num2;
break;
case "m":
result = num1 * num2;
break;
case "d":
// Ask the user to enter a non-zero divisor.
if (num2 != 0)
{
result = num1 / num2;
}
break;
// Return text for an incorrect option entry.
default:
break;
}
return result;
}
}
3. Em seguida, adicione uma nova classe Program , da seguinte maneira:
class Program
{
{
bool endApp = false;
while (!endApp)
{
// Declare variables and set to empty.
string numInput1 = "";
double result = 0;

Console.Write("Type a number, and then press Enter: ");
numInput1 = Console.ReadLine();
double cleanNum1 = 0;
while (!double.TryParse(numInput1, out cleanNum1))
{
Console.Write("This is not valid input. Please enter an integer value: ");
}

Console.Write("Type another number, and then press Enter: ");
{
}
// Ask the user to choose an operator.

Console.WriteLine("Choose an operator from the following list:");
string op = Console.ReadLine();
try
{
result = Calculator.DoOperation(cleanNum1, cleanNum2, op);
if (double.IsNaN(result))
{
Console.WriteLine("This operation will result in a mathematical error.\n");
}
else Console.WriteLine("Your result: {0:0.##}\n", result);
}
catch (Exception e)
{
Console.WriteLine("Oh no! An exception occurred trying to do the math.\n - Details: " +
e.Message);
}

Console.Write("Press 'n' and Enter to close the app, or press any other key and Enter to
continue: ");
if (Console.ReadLine() == "n") endApp = true;
Console.WriteLine("\n"); // Friendly linespacing.

}
return;
}
}
4. Escolha Calculadora para executar seu programa ou pressione F5 .

5. Siga os prompts e divida o número 42 pelo número 119 . O aplicativo deverá ser semelhante à seguinte
captura de tela:
Observe que você tem a opção de inserir mais equações até optar por fechar o aplicativo de console. Além
disso, reduzimos também o número de casas decimais no resultado.
Feche o aplicativo
1. Se você ainda não fez isso, feche o aplicativo de calculadora.
2. Feche o painel Saída no Visual Studio.
3. No Visual Studio, pressione Ctrl +S para salvar seu aplicativo.

4. Feche o Visual Studio.
Conclusão do código
Durante este tutorial, fizemos muitas alterações no aplicativo de calculadora. O aplicativo agora manipula recursos
de computação com mais eficiência e trata a maioria dos erros de entrada do usuário.
Este é o código completo, tudo em um só lugar:
using System;
{
class Calculator
{
public static double DoOperation(double num1, double num2, string op)
{
double result = double.NaN; // Default value is "not-a-number" which we use if an operation, such
as division, could result in an error.

switch (op)
{
case "a":
result = num1 + num2;
break;
case "s":
result = num1 - num2;
break;
case "m":
result = num1 * num2;
break;
case "d":
// Ask the user to enter a non-zero divisor.
if (num2 != 0)
{
{
result = num1 / num2;
}
break;
// Return text for an incorrect option entry.
default:
break;
}
return result;
}
}
class Program
{
{
bool endApp = false;
while (!endApp)
{
// Declare variables and set to empty.
double result = 0;

Console.Write("Type a number, and then press Enter: ");
{
}

Console.Write("Type another number, and then press Enter: ");
{
}
// Ask the user to choose an operator.

Console.WriteLine("Choose an operator from the following list:");
string op = Console.ReadLine();
try
{
result = Calculator.DoOperation(cleanNum1, cleanNum2, op);
if (double.IsNaN(result))
{
Console.WriteLine("This operation will result in a mathematical error.\n");
}
else Console.WriteLine("Your result: {0:0.##}\n", result);
}
catch (Exception e)
catch (Exception e)
{
Console.WriteLine("Oh no! An exception occurred trying to do the math.\n - Details: " +
e.Message);
}

Console.Write("Press 'n' and Enter to close the app, or press any other key and Enter to
continue: ");
if (Console.ReadLine() == "n") endApp = true;
Console.WriteLine("\n"); // Friendly linespacing.

}
return;
}
}
}
Próximas etapas
Parabéns por concluir este tutorial. Para saber ainda mais, acompanhe os tutoriais a seguir.
Continuar com mais tutoriais do C#
Confira também
C# IntelliSense
Aprenda a depurar o código C# no Visual Studio
Tutorial: Introdução ao C# e ao ASP.NET Core no
Visual Studio
Neste tutorial para desenvolvimento em C# com ASP.NET Core usando o Visual Studio, você criará um aplicativo
Web ASP.NET Core em C#, fará alterações, explorará alguns recursos do IDE e então executará o aplicativo.
Antes de começar
Instalar Visual Studio
gratuitamente.
gratuitamente.
Atualizar o Visual Studio
Se você já tiver instalado o Visual Studio, verifique se está executando a versão mais recente. Para obter mais
informações sobre como atualizar sua instalação, consulte o Update Visual Studio para a página de lançamento
mais recente.
Escolher o tema (opcional)
Este tutorial inclui capturas de tela que usam o tema escuro. Se você não estiver usando o tema escuro, mas quiser
usá-lo, confira a página Personalizar o IDE e o Editor do Visual Studio para saber como.
Criar um projeto
Primeiro, você criará um projeto ASP.NET Core. O tipo de projeto vem com todos os arquivos de modelo
necessários para um site totalmente funcional, mesmo antes que você adicione qualquer coisa.
2. Na barra de menu superior, escolha Arquivo > Novo > Projeto .
3. Na caixa de diálogo Novo Projeto no painel esquerdo, expanda Visual C# , expanda Web e escolha .NET
Core . No painel central, escolha Aplicativo Web ASP.NET Core . Em seguida, nomeie o arquivo
MyCoreApp e escolha OK .
Adicionar uma carga de trabalho (opcional)
Se o modelo de projeto Aplicativo Web do ASP.NET Core não for exibido, você poderá obtê-lo adicionando a
carga de trabalho Desenvolvimento ASP.NET e Web . Você pode adicionar essa carga de trabalho de uma das
duas maneiras, dependendo de quais atualizações do Visual Studio 2017 estão instaladas no seu computador.
Opção 1: usar a caixa de diálogo Novo Projeto
1. Clique no link Abrir o Instalador do Visual Studio no painel esquerdo da caixa de diálogo Novo
Projeto . (Dependendo das suas configurações de exibição, talvez seja necessário rolar para vê-la.)
2. O Instalador do Visual Studio é iniciado. Escolha a carga de trabalho ASP.NET e desenvolvimento para a
Web e, em seguida, selecione Modificar .
(Talvez você precise fechar o Visual Studio antes de continuar a instalar a nova carga de trabalho.)
Opção 2: usar a barra de menus Ferramentas
1. Cancele a caixa de diálogo Novo Projeto . Em seguida, na barra de menu superior, escolha Ferramentas >
Obter Ferramentas e Recursos .
2. O Instalador do Visual Studio é iniciado. Escolha a carga de trabalho ASP.NET e desenvolvimento para a
Web e, em seguida, selecione Modificar .
(Talvez você precise fechar o Visual Studio antes de continuar a instalar a nova carga de trabalho.)
Adicionar um modelo de projeto
1. Na caixa de diálogo Novo Aplicativo Web ASP.NET Core , escolha o modelo de projeto Aplicativo Web .
2. Verifique se o ASP.NET Core 2.1 aparece no menu suspenso superior. Em seguida, escolha OK .
NOTE
Se você não vir o ASP.NET Core 2.1 no menu suspenso superior, verifique se você está executando a versão mais
recente do Visual Studio. Para obter mais informações sobre como atualizar sua instalação, consulte o Update Visual
Studio para a página de lançamento mais recente.

2. Na janela Criar um novo projeto , insira ou digite ASP.NET na caixa de pesquisa. Em seguida, escolha C#
na lista Linguagem de programação e, em seguida, escolha Windows na lista Plataforma.
Depois de aplicar os filtros de linguagem de programação e plataforma, escolha o modelo Aplicativo Web
ASP.NET Core (.NET Core) e, em seguida, escolha Avançar .
NOTE
Se não vir o modelo Aplicativo Web ASP.NET Core , você poderá instalá-lo da janela Criar um novo projeto .
Na mensagem Não encontrou o que precisa? , escolha o link Instalar mais ferramentas e recursos .
Em seguida, no Instalador do Visual Studio, escolha a carga de trabalho de desenvolvimento Web e ASP.NET .
Depois disso, escolha o botão Modificar no Instalador do Visual Studio. Se você for solicitado a salvar seu trabalho,
faça isso. Em seguida, escolha Continuar para instalar a carga de trabalho. Em seguida, retorne para a etapa 2 deste
procedimento para "Criar um projeto".
3. Na janela Configurar seu novo projeto , digite ou insira MyCoreApp na caixa Nome do projeto . Em
4. Na janela Criar uma nova janela ASP.NET Do Aplicativo da Web, verifique se ASP.NET Core 3.0
aparece no menu suspenso superior. Em seguida, escolha Aplicativo Web , que inclui Razor Pages de
exemplo. Em seguida, escolha Criar .
O Visual Studio abre seu novo projeto.
Sobre sua solução
Esta solução segue o padrão de design da Página do Razor . Ele é diferente do padrão de design Model-View-
Controller (MVC) que é simplificado para incluir o código do modelo e do controlador na própria página do Razor.
Fazer tour da sua solução

1. O modelo de projeto cria uma solução com um único projeto ASP.NET Core chamado MyCoreApp. Escolha
a guia Gerenciador de Soluções para exibir seu conteúdo.
2. Expanda a pasta Páginas e depois About.cshtml.

3. Visualize o arquivo About.cshtml no editor de códigos.
4. Escolha o arquivo About.cshtml.cs .
5. Visualize o arquivo About.cs no editor de códigos.

6. O projeto também contém a pasta wwwroot que é a raiz do site. Expanda a pasta para exibir seu conteúdo.
Você pode colocar o conteúdo do site estático, como CSS, imagens e bibliotecas JavaScript, diretamente nos
caminhos em que deseja.
7. O projeto também contém arquivos de configuração que gerenciam o aplicativo web em tempo de
execução. A configuração de aplicativo padrão é armazenada em appsettings.json. No entanto, você pode
substituir essas configurações usando appsettings.Development.json. Expanda o arquivo appsettings.json
para exibir o arquivo appsettings.Development.json .
Executar, depurar e fazer alterações

1. Escolha o botão IIS Express no IDE para compilar e executar o aplicativo no modo de Depuração. Como
alternativa, pressione F5 ou escolha Depurar > Iniciar depuração na barra de menus.
NOTE
Se você receber uma mensagem de erro que diz Não conseguir se conectar ao ser vidor web 'IIS Express',
feche o Visual Studio e abra-a usando a opção Executar como administrador a partir do menu de clique siou ou
contexto. Em seguida, execute o aplicativo novamente.
Você também pode obter uma mensagem perguntando se deseja aceitar um certificado SSL do IIS Express. Para
exibir o código em um navegador da Web, escolha Sim e, em seguida, escolha Sim se você receber uma mensagem
de aviso de segurança de acompanhamento.
2. O Visual Studio abre uma janela do navegador. Você deve vê-los na Página Inicial e nas páginas Sobre e
Contato na barra de menus. (Se isso não ocorrer, escolha o item de menu "hambúrguer" para exibi-los).
3. Escolha Sobre na barra de menus.

Entre outras coisas, a página Sobre no navegador renderiza o texto definido no arquivo About.cshtml.
4. Retorne ao Visual Studio e pressione Shift+F5 para interromper o modo de Depuração. Isso também fecha
o projeto na janela do navegador.
5. No Visual Studio, escolha About.cshtml . Em seguida, exclua a palavra adicional e, em seu lugar, adicione as
palavras arquivo e diretório.
6. Escolha About.cshtml.cs . Em seguida, limpe as diretivas using na parte superior do arquivo usando o
seguinte atalho:
Escolha uma das diretivas using esmaecidas, e será exibida a lâmpada Ações Rápidas logo abaixo da seta
ou na margem esquerda. Escolha a lâmpada e, em seguida, escolha Remover Usings Desnecessários .
O Visual Studio exclui as diretivas using desnecessárias do arquivo.
7. Em seguida, no método OnGet() , altere o corpo para o código a seguir:
public void OnGet()

{
string directory = Environment.CurrentDirectory;
Message = String.Format("Your directory is {0}.", directory);
}
8. Observe que dois sublinhados ondulados são exibidos sob Ambiente e Cadeia de caracteres . Os
sublinhados ondulados são exibidos porque esses tipos não estão no escopo.
Abra a barra de ferramentas Lista de Erros para ver os mesmos erros listados. (Se a barra de ferramentas
Lista de Erros não for exibida, escolha Exibir > Lista de Erros na barra de menus superior.)
9. Vamos corrigir isso. No editor de códigos, coloque o cursor na linha que contém o erro e escolha a lâmpada
Ações Rápidas na margem esquerda. No menu suspenso, escolha using System; para adicionar essa
diretiva no topo do arquivo e resolver os erros.
10. Pressione Ctrl +S para salvar suas alterações e pressione F5 para abrir seu projeto no navegador da Web.
11. Na parte superior do site, escolha Sobre para ver as alterações.
12. Feche o navegador da Web, pressione shift +F5 para parar o modo Debug e, em seguida, feche o Visual
Studio.
Fazer tour da sua solução

1. O modelo de projeto cria uma solução com um único projeto ASP.NET Core chamado MyCoreApp. Escolha
a guia Gerenciador de Soluções para exibir seu conteúdo.
2. Expanda a pasta Páginas.

3. Exibir o arquivo Index.cshtml no editor de código.
4. Cada arquivo .cshtml tem um arquivo de código associado. Para abrir o arquivo de código no editor,
expanda o nó Index.cshtml no Solution Explorer e escolha o arquivo Index.cshtml.cs.
5. Veja o arquivo Index.cshtml.cs no editor de código.

6. O projeto também contém a pasta wwwroot que é a raiz do site. Expanda a pasta para exibir seu conteúdo.
Você pode colocar o conteúdo do site estático, como CSS, imagens e bibliotecas JavaScript, diretamente nos
caminhos em que deseja.
7. O projeto também contém arquivos de configuração que gerenciam o aplicativo web em tempo de
execução. A configuração de aplicativo padrão é armazenada em appsettings.json. No entanto, você pode
substituir essas configurações usando appsettings.Development.json. Expanda o arquivo appsettings.json
para exibir o arquivo appsettings.Development.json .
Executar, depurar e fazer alterações
1. Escolha o botão IIS Express no IDE para compilar e executar o aplicativo no modo de Depuração. Como
alternativa, pressione F5 ou escolha Depurar > Iniciar depuração na barra de menus.
NOTE
Se você receber uma mensagem de erro que diz Não conseguir se conectar ao ser vidor web 'IIS Express',
feche o Visual Studio e abra-a usando a opção Executar como administrador a partir do menu de clique siou ou
contexto. Em seguida, execute o aplicativo novamente.
Você também pode obter uma mensagem perguntando se deseja aceitar um certificado SSL do IIS Express. Para
exibir o código em um navegador da Web, escolha Sim e, em seguida, escolha Sim se você receber uma mensagem
de aviso de segurança de acompanhamento.
2. O Visual Studio abre uma janela do navegador. Em seguida, você deve ver Home e páginas de
privacidade na barra de menus.
3. Escolha Privacidade na barra de menus.
A página Privacidade no navegador renderiza o texto definido no arquivo Privacy.cshtml.
4. Retorne ao Visual Studio e pressione Shift+F5 para interromper o modo de Depuração. Isso também fecha
o projeto na janela do navegador.
5. No Visual Studio, abra Privacy.cshtml para edição. Em seguida, exclua as palavras Use esta página para
detalhar a política de privacidade do seu site e, em seu lugar, adicione as palavras que esta página está em
construção a partir de _ @ViewData["TimeStamp"]_.
6. Agora, vamos fazer uma mudança de código. Escolha Privacy.cshtml.cs . Em seguida, limpe as diretivas
using na parte superior do arquivo usando o seguinte atalho:
Escolha uma das diretivas using esmaecidas, e será exibida a lâmpada Ações Rápidas logo abaixo da seta
ou na margem esquerda. Escolha a lâmpada e, em seguida, paire sobre Remover usos desnecessários .
Agora escolha Alterações de visualização para ver o que vai mudar.
Escolha Aplicar . O Visual Studio exclui as diretivas using desnecessárias do arquivo.

7. Em seguida, no método OnGet() , altere o corpo para o código a seguir:
public void OnGet()

{
string dateTime = DateTime.Now.ToShortDateString();
ViewData["TimeStamp"] = dateTime;
}
8. Observe que dois sublinhados ondulados aparecem em DateTime . Os sublinhados ondulados aparecem
porque este tipo não está no escopo.
Abra a barra de ferramentas Lista de Erros para ver os mesmos erros listados. (Se a barra de ferramentas
Lista de Erros não for exibida, escolha Exibir > Lista de Erros na barra de menus superior.)
9. Vamos corrigir isso. No editor de códigos, coloque o cursor na linha que contém o erro e escolha a lâmpada
Ações Rápidas na margem esquerda. No menu suspenso, escolha using System; para adicionar essa
diretiva no topo do arquivo e resolver os erros.
10. Pressione F5 para abrir seu projeto no navegador da Web.

11. Na parte superior do site, escolha Privacidade para visualizar suas alterações.
12. Feche o navegador da Web, pressione shift +F5 para parar o modo Debug e, em seguida, feche o Visual
Studio.
Perguntas frequentes com respostas rápidas

Aqui estão algumas perguntas frequentes rápidas para destacar alguns conceitos principais.
O que é C#?
C# é uma linguagem de programação fortemente tipada e orientada a objeto projetada para ser robusta e fácil de
aprender.
O que é ASP.NET Core?
O ASP.NET Core é uma estrutura de software livre e de multiplataforma para a compilação de aplicativos
modernos conectados à Internet, como serviços e aplicativos Web. Aplicativos ASP.NET Core podem ser
executados no .NET Core ou o .NET Framework. Você pode desenvolver e executar aplicativos ASP.NET Core de
multiplataforma no Windows, Mac e Linux. O ASP.NET Core é um software livre no GitHub.
O que é o Visual Studio?
Visual Studio é um pacote de desenvolvimento integrado de ferramentas de produtividade para desenvolvedores.
Pense nele como um programa que você pode usar para criar programas e aplicativos.
Próximas etapas
Parabéns por concluir este tutorial. Esperamos que você tenha aprendido um pouco sobre o C#, o ASP.NET Core e
o IDE do Visual Studio. Para saber mais sobre como criar um aplicativo Web ou site em C# com o ASP.NET,
continue com os tutoriais a seguir:
Crie um aplicativo web Razor Pages com ASP.NET Core
Confira também
Publicar seu aplicativo Web no Serviço de Aplicativo do Azure usando o Visual Studio
Tutorial: Crie seu primeiro aplicativo Universal
Windows Platform no Visual Studio com XAML e C#
Nesta introdução ao IDE (ambiente de desenvolvimento integrado) do Visual Studio, você criará um aplicativo "Olá,
Mundo" que poderá ser executado em qualquer dispositivo Windows 10. Para fazer isso, você usará um modelo de
projeto da UWP (Plataforma Universal do Windows), a linguagem XAML e a linguagem de programação C#.
gratuitamente.
gratuitamente.
Criar um projeto
Primeiro, crie um projeto da Plataforma Universal do Windows. O tipo de projeto vem com todos os arquivos de
modelo que você precisa, antes mesmo de você adicionar alguma coisa!
3. No painel esquerdo da caixa de diálogo Novo Projeto , expanda Visual C# e, em seguida, escolha
Universal do Windows . No painel do meio, escolha Aplicativo em Branco (Universal do Windows) .
Em seguida, nomeie o projeto como HelloWorld e escolha OK .
NOTE
Certifique-se de que a localização do projeto de origem está em uma unidade formatado ntfs (New Technology
File System, sistema de arquivos de nova tecnologia), como a unidade do sistema operacional (OS). Caso contrário,
você pode ter problemas para construir e executar o seu projeto.
NOTE
Se o modelo de projeto Aplicativo em Branco (Universal do Windows) não for exibido, clique no link Abrir
Instalador do Visual Studio no painel esquerdo da caixa de diálogo Novo Projeto .
O Instalador do Visual Studio é iniciado. Escolha a carga de trabalho Desenvolvimento na Plataforma Universal
do Windows e, em seguida, selecione Modificar .
4. Aceite as configurações padrão de Versão de destino e de Versão mínima na caixa de diálogo Novo
Projeto da Plataforma Universal do Windows .
1. Abra o Visual Studio e, na janela de início, selecione Criar um novo projeto .
2. Na janela Criar um novo projeto , insira Universal Windows na caixa de pesquisa, escolha o modelo C #
para Aplicativo em Branco (Universal Windows) e, em seguida, escolha Próximo .
NOTE
Se você não vir o modelo de projeto **Aplicativo em Branco (Universal Windows) **, clique no link Instalar mais
ferramentas e recursos .
O Instalador do Visual Studio é iniciado. Escolha a carga de trabalho Desenvolvimento na Plataforma Universal
do Windows e, em seguida, selecione Modificar .
3. Dê um nome ao projeto, HelloWorld, e escolha Criar .
4. Aceite as configurações padrão de Versão de destino e de Versão mínima na caixa de diálogo Novo
Projeto da Plataforma Universal do Windows .
NOTE
Se esta for a primeira vez que você usa o Visual Studio para criar um aplicativo UWP, uma caixa de diálogo Configurações
poderá aparecer. Selecione Modo do Desenvolvedor e, em seguida, escolha Sim .
O Visual Studio instala um pacote de Modo do Desenvolvedor adicional. Quando o pacote de instalação for concluído, feche a
caixa de diálogo Configurações .
Criar o aplicativo
É hora de começar a desenvolver. Você vai adicionar um controle de botão, adicionar uma ação para o botão e, em
seguida, iniciar o aplicativo "Olá, Mundo" para ver sua aparência.
Adicionar um botão à tela de Design
1. No Gerenciador de Soluções , clique duas vezes em MainPage.xaml para abrir o modo divisão.
Existem dois painéis: o Designer XAML , que inclui uma tela de design e o Editor de XAML , no qual você
pode adicionar ou alterar o código.
2. Escolha Caixa de ferramentas para abrir a janela de submenu Caixa de Ferramentas.
(Se a opção Caixa de Ferramentas não for exibida, ela poderá ser aberta na barra de menus. Para isso,
escolha Exibir > barra de ferramentas . Ou pressione Ctrl +Alt +X .)
3. Clique no ícone Fixar para encaixar a janela Caixa de Ferramentas.
4. Clique no controle de Botão e, em seguida, arraste-o para a tela de design.
Se você olhar para o código no Editor XAML, verá que o botão foi adicionado lá também:
Adicionar um rótulo para o botão

1. No Editor XAML, altere o valor do conteúdo do botão de "Button" para "Hello World!"
2. Observe que o botão no XAML Designer também muda.

Adicionar um manipulador de eventos
O termo "Manipulador de eventos" parece complicado, mas é apenas outro nome para o código que é chamado
quando ocorre um evento. Nesse caso, ele adiciona uma ação para o "Olá, Mundo!" .
1. Clique duas vezes no controle de botão na tela de design.
2. Edite o código do manipulador de eventos em MainPage.xaml.cs, a página code-behind.
É aqui que as coisas ficam interessantes. O manipulador de eventos padrão tem esta aparência:
Vamos alterá-lo, para que fique assim:
Aqui está o código a ser copiado e colado:

private async void Button_Click(object sender, RoutedEventArgs e)
{
MediaElement mediaElement = new MediaElement();
var synth = new Windows.Media.SpeechSynthesis.SpeechSynthesizer();
Windows.Media.SpeechSynthesis.SpeechSynthesisStream stream = await
synth.SynthesizeTextToStreamAsync("Hello, World!");
mediaElement.SetSource(stream, stream.ContentType);
mediaElement.Play();
}
O que nós acabamos de fazer?

O código usa algumas APIs do Windows para criar um objeto de sintetização de voz e, em seguida, fornece um
texto para ele dizer. (Para obter mais informações de como usar SpeechSynthesis , confira
System.Speech.Synthesis.)
Executar o aplicativo
É hora de criar, implantar e iniciar o aplicativo UWP "Olá, Mundo" para ver como ele é e como ele soa. Veja como.
1. Use o botão Play (ele tem o texto Computador Local ) para iniciar o aplicativo no computador local.
(Como alternativa, você pode escolher Depurar > Iniciar Depuração na barra de menus ou pressionar F5
para iniciar seu aplicativo.)
2. Veja o aplicativo, que aparece logo depois que uma tela inicial desaparece. O aplicativo deve ser semelhante
a este:
3. Clique no botão Olá, Mundo .
Seu dispositivo Windows 10 dirá literalmente "Olá, Mundo!"
4. Para fechar o aplicativo, clique no botão Parar Depuração na barra de ferramentas. (Alternativamente,
escolha Debug > Stop depuração na barra de menu ou pressione Shift+F5.)
É hora de criar, implantar e iniciar o aplicativo UWP "Olá, Mundo" para ver como ele é e como ele soa. Veja como.
1. Use o botão Play (ele tem o texto Computador Local ) para iniciar o aplicativo no computador local.
(Como alternativa, você pode escolher Depurar > Iniciar Depuração na barra de menus ou pressionar F5
para iniciar seu aplicativo.)
2. Veja o aplicativo, que aparece logo depois que uma tela inicial desaparece. O aplicativo deve ser semelhante
a este:
3. Clique no botão Olá, Mundo .

Seu dispositivo Windows 10 dirá literalmente "Olá, Mundo!"
4. Para fechar o aplicativo, clique no botão Parar Depuração na barra de ferramentas. (Alternativamente,
escolha Debug > Stop depuração na barra de menu ou pressione Shift+F5.)
Próximas etapas
Parabéns por concluir este tutorial. Esperamos que você tenha aprendido algumas noções básicas sobre a UWP e o
IDE do Visual Studio. Para saber mais, continue com o tutorial a seguir:
Criar uma interface do usuário
Confira também
Visão Geral da UWP
Obter exemplos de aplicativo UWP
Tutorial: Crie um aplicativo simples com C#
Ao concluir este tutorial, você estará familiarizado com vários designers, ferramentas e caixas de diálogo que
poderão ser usados no desenvolvimento de aplicativos com o Visual Studio. Você vai criar um aplicativo "Olá,
Mundo", projetar a interface do usuário, adicionar código e depurar erros enquanto aprende sobre o trabalho no
IDE (ambiente de desenvolvimento integrado).
Pré-requisitos
gratuitamente.
gratuitamente.
Você pode usar o .NET Framework ou o .NET Core para este tutorial. .NET Core é a estrutura mais nova e
moderna. .NET Core requer visual studio 2019 versão 16.3 ou posterior.
Configurar o IDE
Ao abrir o Visual Studio pela primeira vez, você será solicitado a entrar. Esta etapa é opcional neste tutorial. Em
seguida, você poderá ver uma caixa de diálogo que solicita a escolha das configurações de desenvolvimento e o
tema de cores. Mantenha os padrões e escolha Iniciar o Visual Studio .
Depois que o Visual Studio for iniciado, você verá as janelas de ferramentas, os menus e as barras de ferramentas,
bem como o espaço da Janela principal. As janelas de ferramentas estão encaixadas nos lados esquerdo e direito da
janela do aplicativo, com Início Rápido , a barra de menus e a barra de ferramentas padrão na parte superior. No
centro da janela do aplicativo está a Página Inicial . Ao carregar uma solução ou um projeto, os editores e
designers são exibidos no espaço em que a Página Inicial está localizada. Ao desenvolver um aplicativo, você
passará a maior parte do seu tempo nessa área central.
Quando você inicia o Visual Studio, a janela de início é aberta primeiro. Selecione Continuar sem código para
abrir o ambiente de desenvolvimento. Você verá as janelas de ferramentas, os menus e as barras de ferramentas,
além do espaço da janela principal. As janelas de ferramentas estão encaixadas nos lados esquerdo e direito da
janela do aplicativo, com uma caixa de pesquisa, a barra de menus e a barra de ferramentas padrão na parte
superior. Quando você carrega uma solução ou um projeto, os editores e designers são exibidos no espaço central
da janela do aplicativo. Ao desenvolver um aplicativo, você passará a maior parte do seu tempo nessa área central.
Criar o projeto
Ao criar um aplicativo no Visual Studio, você cria primeiro um projeto e uma solução. Para este exemplo, você
criará um projeto do WPF (Windows Presentation Foundation).
1. Criar um novo projeto. Na barra de menu, selecione Arquivo > Novo > Projeto .
2. Na caixa de diálogo Novo Projeto , selecione a categoria Instalado > Visual C# > Área de Trabalho do
Windows e, em seguida, selecione o modelo Aplicativo WPF (.NET Framework) . Nomeie o projeto
como HelloWPFApp e selecione OK .
2. Na tela Iniciar, selecione Criar projeto .
3. Na criação de uma nova tela de projeto, procure por "WPF", escolha WPF App (.NET Core) e escolha
Next .
NOTE
Você pode encontrar dois modelos de desktop WPF, um para .NET Framework e outro para .NET Core. O modelo .NET
Core está disponível na versão 16.3 do Visual Studio 2019 e posterior. Você pode usar qualquer um para este tutorial,
mas recomendamos .NET Core para novo desenvolvimento.
4. Na próxima tela, dê o nome HelloWPFApp ao projeto e escolha Criar .
O Visual Studio cria o projeto e a solução HelloWPFApp e o Gerenciador de Soluções mostra os diversos
arquivos. O Designer do WPF mostra um modo de exibição de Design e um modo de exibição XAML de
MainWindow.xaml em um modo divisão. É possível deslizar o divisor para mostrar mais ou menos de cada
exibição. É possível optar por ver apenas a exibição visual ou apenas a exibição XAML.
NOTE
Para saber mais informações sobre XAML (eXtensible Application Markup Language), confira a página Visão geral do XAML
para WPF.
Depois de criar o projeto, você poderá personalizá-lo. Para tanto, escolha Janela de Propriedades do menu
Exibir , ou pressione F4 . Em seguida, você pode exibir e alterar opções de itens de projeto, controles e outros itens
em um aplicativo.
Alterar o nome de MainWindow.xaml

Vamos dar um nome mais específico para MainWindow. No Solution Explorer, clique com o botão direito do
mouse em MainWindow.xaml e escolha Renomear . Renomeie o arquivo para Greetings.xaml.
Criar a interface do usuário

Se o designer não estiver aberto, selecione Greetings.xaml e pressione Shift +F7 para abrir o designer.
Adicionaremos três tipos de controles a este aplicativo: um controle TextBlock, dois controles RadioButton e um
controle Button.
Adicionar um controle TextBlock
1. Pressione Ctrl +Q para ativar a caixa de pesquisa e digitar caixa de ferramentas . Escolha Exibir > Caixa
de ferramentas na lista de resultados.
2. No Caixa de Ferramentas , expanda o nó Controles Comuns do WPF para ver o controle TextBlock.
3. Adicione um controle TextBlock à superfície de design escolhendo o item TextBlock e arrastando-o para a
janela na superfície de design. Centralize o controle próximo à parte superior da janela. No Visual Studio
2019 e posterior, você pode usar as diretrizes vermelhas para centralizar o controle.
Sua janela deve se parecer com a ilustração a seguir:
A marcação XAML deve ter uma aparência semelhante ao exemplo a seguir:
<Grid>
<TextBlock HorizontalAlignment="Left" Margin="387,60,0,0" TextWrapping="Wrap" Text="TextBlock"
VerticalAlignment="Top"/>
</Grid>
Personalizar o texto no bloco de texto

1. Na exibição XAML, localize a marcação TextBlock e altere o atributo Text de TextBox para
Select a message option and then choose the Display button.
A marcação XAML deve ter uma aparência semelhante ao exemplo a seguir:
<Grid>
<TextBlock HorizontalAlignment="Left" Margin="387,60,0,0" TextWrapping="Wrap" Text="Select a message
option and then choose the Display button." VerticalAlignment="Top"/>
</Grid>
2. Se necessário, centralize novamente o TextBlock e salve as alterações pressionando Ctrl+S ou usando o
item de menu Arquivo .
Em seguida, você adicionará dois controles RadioButton ao formulário.
Adicionar botões de opção
1. Na Caixa de Ferramentas , localize o controle RadioButton .
2. Adicione dois controles RadioButton à superfície de design escolhendo o item RadioButton e arrastando-o
para a janela na superfície de design. Mova os botões (selecionando-os e usando as teclas de direção) para
que os botões sejam exibidos lado a lado sob o controle TextBlock. Use as diretrizes vermelhas para alinhar
os controles.
A sua janela deve se parecer com esta:
3. Na janela Propriedades do controle RadioButton esquerdo, altere a propriedade Nome (a propriedade na

parte superior da janela Propriedades ) para HelloButton .
4. Na janela Propriedades do controle RadioButton direito, altere a propriedade Name para GoodbyeButton e,
em seguida, salve as alterações.
Em seguida, adicione o texto de exibição para cada controle RadioButton. O procedimento a seguir atualiza a
propriedade Conteúdo de um controle RadioButton.
Adicionar o texto de exibição de cada botão de opção
1. Atualize o atributo GoodbyeButton "Hello" Conteúdo para o HelloButton e para e "Goodbye" no XAML. A
marcação XAML deve agora ser semelhante ao exemplo a seguir:
<Grid>
<TextBlock HorizontalAlignment="Left" Margin="252,47,0,0" TextWrapping="Wrap" Text="Select a
message option and then choose the Display button." VerticalAlignment="Top"/>
<RadioButton x:Name="HelloButton" Content="Hello" HorizontalAlignment="Left" Margin="297,161,0,0"
VerticalAlignment="Top"/>
<RadioButton x:Name="GoodbyeButton" Content="Goodbye" HorizontalAlignment="Left"
Margin="488,161,0,0" VerticalAlignment="Top"/>
</Grid>
Definir que um botão de opção faça check-in por padrão

Nesta etapa, definiremos que o HelloButton permaneça marcado por padrão, de maneira que um dos dois botões
de opção esteja sempre selecionado.
1. Na exibição XAML, localize a marcação HelloButton.
2. Adicione um atributo IsChecked e configure-o como True . Especificamente, adicione IsChecked="True" .
A marcação XAML deve agora ser semelhante ao exemplo a seguir:
<Grid>
<RadioButton x:Name="HelloButton" Content="Hello" IsChecked="True" HorizontalAlignment="Left"
</Grid>
O elemento final de iu que você adicionará é um controle button.

Adicionar o controle de botão
1. Na Caixa de Ferramentas , localize o controle de Botão e, em seguida, adicione-o à superfície de design
sob os controles RadioButton, arrastando-o para o formulário no modo de exibição de Design. Se você
estiver usando o Visual Studio 2019 ou posterior, uma linha vermelha ajuda você a centralizar o controle.
2. Na exibição XAML, altere o valor de Conteúdo do controle de Botão, de Content="Button" para
Content="Display" e salve as alterações.
Sua janela deve se parecer com a ilustração a seguir.

A marcação XAML deve agora ser semelhante ao exemplo a seguir:
<Grid>
<RadioButton x:Name="HelloButton" Content="Hello" IsChecked="True" HorizontalAlignment="Left"
<Button Content="Display" HorizontalAlignment="Left" Margin="377,270,0,0" VerticalAlignment="Top"
Width="75"/>
</Grid>
Adicionar um código ao botão de exibição

Quando esse aplicativo é executado, uma caixa de mensagem é exibida depois que um usuário escolhe um botão
de opção e, em seguida, escolhe o botão Exibir . Uma caixa de mensagem será exibida para Olá e outra para Até
logo. Para criar esse comportamento, adicione um código ao evento Button_Click em Greetings.xaml.cs.
1. Na superfície de design, clique duas vezes no botão Exibição .
Greetings.xaml.cs é aberto, com o cursor no evento Button_Click .
private void Button_Click(object sender, RoutedEventArgs e)

{
2. Insira o seguinte código:

if (HelloButton.IsChecked == true)
{
MessageBox.Show("Hello.");
}
else if (GoodbyeButton.IsChecked == true)
{
MessageBox.Show("Goodbye.");
}
3. Salve o aplicativo.
Depurar e testar o aplicativo

Em seguida, você depurará o aplicativo para procurar erros e testar se ambas as caixas de mensagem são exibidas
corretamente. As instruções a seguir descrevem como criar e iniciar o depurador, mas, posteriormente, leia
Compilar um aplicativo WPF (WPF) e Depurar o WPF para obter mais informações.
Localizar e corrigir erros
Nesta etapa, você encontrará o erro que causamos anteriormente alterando o nome do arquivo MainWindow.xaml.
Iniciar a depuração e localizar o erro
1. Inicie o depurador pressionando F5 ou selecionando Depurar e depois Iniciar Depuração .
Uma janela de Modo de Interrupção é exibida e a janela Saída indica que houve uma IOException: não é
possível localizar o recurso 'mainwindow.xaml'.
2. Pare o depurador escolhendo Debug > Stop Debugging .

Renomeamos o MainWindow.xaml como Greetings.xaml no início deste tutorial, mas o código ainda se refere a
MainWindow.xaml como o URI de inicialização do aplicativo. Portanto, o projeto não pode ser iniciado.
Especificar Greetings.xaml como o URI de inicialização
1. No Gerenciador de Soluções , abra o arquivo App.xaml.
2. Altere StartupUri="MainWindow.xaml" para StartupUri="Greetings.xaml" e salve as alterações.
Inicie o depurador novamente (pressione F5 ). Você deverá ver a janela Saudações do aplicativo.
Agora, feche a janela do aplicativo para parar a depuração.
Depurar com pontos de interrupção
Você pode testar o código durante a depuração ao adicionar alguns pontos de interrupção. Você pode adicionar
pontos de interrupção escolhendo Debug > Toggle Breakpoint , clicando na margem esquerda do editor ao lado
da linha de código onde você deseja que a quebra ocorra, ou pressionando F9 .
Adicionar pontos de interrupção
1. Abra Greetings.xaml.cse selecione a seguinte linha: MessageBox.Show("Hello.")
2. Adicione um ponto de interrupção por meio do menu selecionando Depurar e, em seguida,
Ativar/Desativar Ponto de Interrupção .
Um círculo vermelho aparece ao lado da linha de código na margem da extrema esquerda da janela do
editor.
3. Selecione a linha a seguir: MessageBox.Show("Goodbye.") .
4. Pressione a tecla F9 para adicionar um ponto de interrupção e, em seguida, pressione F5 para iniciar a
depuração.
5. Na janela Saudações , escolha o botão de opção Olá e depois o botão Exibição .
A linha MessageBox.Show("Hello.") é realçada em amarelo. Na parte inferior do IDE, as janelas Automáticos,
Locais e Inspeção estão encaixadas juntas no lado esquerdo e as janelas Pilha de Chamadas, Pontos de
Interrupção, Configurações de Exceção, Comando, Imediato e Saída estão encaixadas no lado direito.
6. Na barra de menu, escolha Debug > Step Out .

O aplicativo retomará a execução e uma caixa de mensagem com a palavra "Olá" será exibida.
7. Escolha o botão OK na caixa de mensagem para fechá-la.
8. Na janela Saudações , escolha o botão de opção Até logo e depois o botão Exibição .
A linha MessageBox.Show("Goodbye.") é realçada em amarelo.
9. Escolha a tecla F5 para continuar a depuração. Quando a caixa de mensagem for exibida, escolha o botão
OK na caixa de mensagem para fechá-la.
10. Feche a janela do aplicativo para parar a depuração.
11. Na barra de menu, escolha Desativar > todos os pontos de interrupção .
Exibir uma representação dos elementos da UI
No aplicativo em execução, você deve ver um widget que aparece na parte superior da janela. Este é um ajudante
de tempo de execução que fornece acesso rápido a alguns recursos úteis de depuração. Clique no primeiro botão,
Vá para Ár vore Visual Ao Vivo . Você deve ver uma janela com uma árvore que contém todos os elementos
visuais de sua página. Expanda os nós para encontrar os botões adicionados.
Criar uma versão de lançamento do aplicativo
Agora que você verificou que tudo está funcionando, já pode preparar um build de versão do aplicativo.
1. No menu principal, selecione Build > Clean solução para excluir arquivos intermediários e arquivos de
saída que foram criados durante compilações anteriores. Isso não é necessário, mas limpa as saídas de build
da depuração.
2. Alterar a configuração de compilação para HelloWPFApp de Debug para Release usando o controle de
dropdown na barra de ferramentas (diz "Debug" atualmente).
3. Construa a solução escolhendo build > build solution .
Parabéns por concluir este tutorial. Você pode encontrar o .exe que você construiu sua solução e diretório de
projeto (...\HelloWPFApp\HelloWPFApp\bin\Release).
Próximas etapas
Parabéns por concluir este tutorial. Para saber ainda mais, acompanhe os tutoriais a seguir.
Continuar com mais tutoriais do WPF
Confira também
Dicas de produtividade
Crie um aplicativo do Windows Forms no Visual
Studio com C #
Nesta breve introdução ao ambiente de desenvolvimento integrado do Visual Studio (IDE), você criará um
aplicativo C# simples que tem uma interface de usuário baseada no Windows (UI).
gratuitamente.
gratuitamente.
NOTE
Algumas das capturas de tela neste tutorial usam o tema escuro. Se você não estiver usando o tema escuro, mas quiser usá-
lo, confira a página Personalizar o IDE e o Editor do Visual Studio para saber como.
Criar um projeto
Primeiro, você criará um projeto de aplicativo em C#. O tipo de projeto inclui todos os arquivos de modelo que
você precisará, mesmo sem adicionar nada.
3. Na caixa de diálogo Novo Projeto no painel esquerdo, expanda o Visual C# e escolha o Windows
Desktop . No painel central, selecione Aplicativo do Windows Forms (.NET Framework) . Em seguida,
dê o nome HelloWorld para o arquivo.
Se o modelo de projeto Aplicativo do Windows Forms (.NET Framework) não for exibido, cancele a
caixa de diálogo Novo Projeto e, na barra de menus superior, escolha Ferramentas > Obter
Ferramentas e Recursos . O Instalador do Visual Studio é iniciado. Escolha a carga de trabalho
Desenvolvimento de área de trabalho do .NET e, em seguida, selecione Modificar .

3. Na criação de uma nova janela de projeto, escolha o modelo do Aplicativo de formulários do Windows
(.NET Framework) para C#.
(Se preferir, você pode refinar sua pesquisa para chegar rapidamente ao modelo que deseja. Por exemplo,
digite ou digite o Aplicativo de Formulários do Windows na caixa de pesquisa. Em seguida, escolha C# na
lista de idiomas e escolha o Windows na lista Plataforma.)
NOTE
Se você não encontrar o modelo do Aplicativo do Windows Forms (.NET Framework) , poderá instalá-lo a partir
da janela Criar um novo projeto . Na mensagem Não encontrou o que precisa? , escolha o link Instalar mais
ferramentas e recursos .
Em seguida, no Instalador do Visual Studio, escolha Escolher a carga de trabalho de desenvolvimento de área de
trabalho do .NET .
Depois disso, escolha o botão Modificar no Instalador do Visual Studio. Pode ser solicitado que você salve seu
trabalho; nesse caso, faça isso. Em seguida, escolha Continuar para instalar a carga de trabalho. Em seguida, retorne
para a etapa 2 deste procedimento para "Criar um projeto".
4. Na janela Configurar seu novo projeto , digite ou insira OláMundo na caixa Nome do projeto . Em
Criar o aplicativo
Depois de selecionar o modelo de projeto C# e nomear seu arquivo, o Visual Studio abre um formulário para você.
Um formulário é uma interface do usuário do Windows. Criaremos um aplicativo "Hello World" adicionando
controles ao formulário e, em seguida, executaremos o aplicativo.
Adicionar um botão no formulário
1. Escolha Caixa de ferramentas para abrir a janela de submenu Caixa de Ferramentas.
(Se você não encontrar a opção suspensa Caixa de Ferramentas , ela poderá ser aberta da barra de menus.
Para isso, exibir > caixa de ferramentas . Ou pressione Ctrl +Alt +X .)
2. Escolha o ícone Pin para acoplar a janela Caixa de ferramentas.
3. Escolha o controle Button e arraste-o para o formulário.

4. Na janela Propriedades, localize Texto, altere Click this o nome de Button1 para e, em seguida,
pressione Enter .
(Se você não encontrar a janela Propriedades , ela poderá ser aberta da barra de menus. Para isso, escolha
'Exibir > janela propriedades'. Ou, pressione F4 .)
5. Na seção Design da janela Propriedades , altere o nome de Button1 para btnClickThis e, em seguida,
pressione Enter .
NOTE
Se você tiver alfabetizado a lista na janela Propriedades, Button1 aparecerá na seção (Databindings) em vez
disso.
Adicionar um rótulo ao formulário

Agora que adicionamos um controle de botão para criar uma ação, vamos adicionar um controle de rótulo para
enviar o texto.
1. Selecione o controle Rótulo da janela Caixa de Ferramentas e, então, arraste-a para o formulário e solte-a
abaixo do botão Clique aqui .
2. Na seção Design ou na seção (DataBindings) da janela Propriedades, altere o nome de Label1 para
lblHelloWorld e, em seguida, pressione Enter .
Adicionar código ao formulário

1. Na janela ]Form1.cs [Design, clique duas vezes no botão "Clique neste botão para abrir a janela
Form1.cs.
(Alternativamente, você pode expandir Form1.cs no Solution Explorer e, em seguida, escolher
Formulário1 .)
2. Na janela Form1.cs, após a linha de lblHelloWorld.Text = "Hello World!"; vazio privado, digite ou digite
conforme mostrado na captura de tela a seguir:
1. Escolha o botão Iniciar para executar o aplicativo.
Várias coisas acontecerão. No IDE do Visual Studio, a janela Ferramentas de Diagnóstico será aberta, e
uma janela de saída também. Porém, fora do IDE, uma caixa de diálogo Form1 será exibida. Ela incluirá o
botão Clique aqui e o texto Label1 .
2. Escolha o botão Clique neste botão na caixa de diálogo Form1. Observe que o texto Label1 é alterado
para Olá, Mundo! .
3. Feche a caixa de diálogo Form1 para parar de executar o aplicativo.
Próximas etapas
Para saber mais, continue com o tutorial a seguir:
Tutorial: Crie um visualizador de imagens
Confira também
Mais tutoriais C#
Tutoriais sobre Visual Basic
Tutoriais c++
Tutorial: Crie seu primeiro ASP.NET Aplicativo Core
usando o Entity Framework com o Visual Studio 2019
Neste tutorial, você criará um aplicativo Web ASP.NET Core que usa dados e o implantará no Azure. O tutorial
consiste nas seguintes etapas:
Passo 1: Instalar o Visual Studio 2019
Passo 2: Crie seu primeiro aplicativo web ASP.NET Core
Passo 3: Trabalhar com dados usando o Framework entityentity
Passo 4: Exponha uma API web do seu aplicativo ASP.NET Core
Passo 5: Implante seu aplicativo ASP.NET Core para o Azure
Passo 1: Instalar o Visual Studio 2019

Aprenda como instalar o Visual Studio 2019 com este tutorial em vídeo e instruções passo a passo. Se você já
instalou o Visual Studio, pule para o Passo 2: Crie seu primeiro aplicativo web ASP.NET Core.
Assista a este vídeo e siga as etapas para instalar o Visual Studio e criar seu primeiro aplicativo Web ASP.NET Core.
Baixar o Instalador
Vá para visualstudio.com para localizar o instalador. Localize o link do Visual Studio 2019 e clique nele para iniciar
o download. Para obter uma versão gratuita do Visual Studio, escolha Visual Studio Community.
Iniciar o instalador
Após a conclusão do download, clique em Executar para iniciar o instalador.
Escolha as cargas de trabalho
O Visual Studio pode ser usado para muitos tipos diferentes de desenvolvimento, e as cargas de trabalho facilitam
o download de tudo o que é necessário para o tipo de aplicativo que você deseja criar. Escolha as cargas de
trabalho Desenvolvimento de ASP.NET e Web e Desenvolvimento de plataforma cruzada .NET Core por
enquanto. Você poderá reiniciar o instalador mais tarde para instalar componentes e cargas de trabalho adicionais.
Instalar
Clique em Instalar e permitir que o instalador baixe e instale o Visual Studio.
Executar o Visual Studio pela primeira vez

O Visual Studio deve ser iniciado automaticamente quando o instalador for concluído. Você pode ser solicitado a
entrar, pois há alguns recursos interessantes associados a ele, mas, por enquanto, você pode optar por fazer isso
posteriormente. Em seguida, você pode escolher as configurações de tema e desenvolvimento. Depois de definir
essas opções, você estará pronto para iniciar seu primeiro projeto. Clique em Criar um novo projeto e, em
seguida, escolha Aplicativo Web ASP.NET Core .
Explorar os tipos de projeto do ASP.NET Core
Escolha o nome e o local do projeto e clique em Criar . Agora, escolha qual modelo usar em seu aplicativo ASP.NET
Core. É possível escolher um das seguintes opções:
Vazio. Um modelo de projeto vazio que permite começar do zero.
API. O melhor para APIs Web.
Aplicativo Web. Um aplicativo Web ASP.NET Core padrão criado com Razor Pages.
Aplicativo Web (Model-View-Controller). Um aplicativo Web ASP.NET Core padrão usando o padrão Model-
View-Controller.
Angular.
React.js.
React.js/Redux.
Biblioteca de classes Razor. Usado para compartilhar ativos Razor entre projetos.
Para a maioria dos modelos de projeto, também é possível habilitar o suporte ao Docker marcando uma caixa.
Você também pode adicionar suporte à autenticação clicando no botão Alterar autenticação. Lá, escolha entre:
Sem Autenticação.
Contas de Usuários Individuais. Elas são armazenadas em um banco de dados local ou baseado no Azure.
Contas corporativas ou de estudante. Essa opção usa o Active Directory, Azure AD ou Office 365 para
autenticação.
Autenticação do Windows. Adequada para aplicativos da intranet.
Selecione o modelo padrão do Aplicativo web sem autenticação e clique em Criar .
Próximas etapas
No próximo vídeo, você aprenderá mais sobre o seu primeiro projeto do ASP.NET Core.
Tutorial: Criando seu primeiro ASP.NET aplicativo web principal
Confira também
Tutorial: Comece com C# e ASP.NET Core Um tutorial mais detalhado sem um passo a passo em vídeo
Passo 2: Crie seu primeiro aplicativo web ASP.NET
Core
Crie seu primeiro aplicativo Web ASP.NET Core com este tutorial em vídeo e instruções passo a passo.
Assista a este vídeo e acompanhe-o para criar seu primeiro aplicativo Web ASP.NET Core.
Iniciar o Visual Studio 2019 e criar um projeto

Inicie o Visual Studio 2019 e clique em Criar um projeto . Escolha Aplicativo Web ASP.NET Core . Escolha o
modelo Aplicativo Web e mantenha o nome e local padrão do projeto. Na versão dropdown com a versão
ASP.NET Core, escolha ASP.NET Core 2.1 ou ASP.NET Core 2.2 . Clique em Criar . Para obter instruções mais
detalhadas, consulte o vídeo anterior nesta série de tutoriais.
WARNING
Certifique-se de escolher ASP .NET Core 2.1 ou ASP.NET Core 2.2. Este tutorial não é compatível com ASP.NET Core 3.x.
Explorar o novo projeto

Na janela do gerenciador de soluções, à direita, você pode exibir os conteúdos do novo projeto. Eles são descritos
aqui.
wwwroot
A pasta wwwroot contém arquivos estáticos que estarão publicamente acessíveis do aplicativo Web.
Normalmente, ele contém folhas de estilo, arquivos de script do lado do cliente e imagens.
Pages (Páginas)
A pasta Pages contém as Razor Pages do site. O modelo padrão fornece várias páginas, incluindo a página
Index.cshtml que é a home page do aplicativo, bem como Sobre, Contato e assim por diante.
appsettings.json
Esse arquivo contém as definições de configuração do site, no formato JSON.
Module.vb
Esse arquivo age como o ponto de entrada para o aplicativo. Quando o aplicativo é executado, o método Main é o
primeiro método que é executado e é responsável por criar o Host da Web que conterá o aplicativo.
Startup.cs
O Host da Web criado no Program.cs faz referência à classe Startup e chama os respectivos métodos para
configurar o aplicativo. O método ConfigureServices é responsável por configurar quaisquer serviços que o
aplicativo usará. O método Configure configura o pipeline de solicitação HTTP do aplicativo. Cada solicitação
passa por esse pipeline e, conforme o faz, interage com cada parte do middleware.
Index.cshtml
A home page para o site inclui um pouco de marcação HTML e algum código do Razor do lado servidor. Ele usa o
Razor para especificar o modelo de página, IndexModel , que está localizado no arquivo Index.cshtml.cs associado.
Ele também define o título da página, definindo um valor em ViewData. Esse valor ViewData é lido no * _arquivo
Layout.cshtml,* localizado na pasta Compartilhada dentro da pasta Páginas. O arquivo de Layout é compartilhado
por várias Razor Pages e fornece a aparência e experiência comuns para o aplicativo. O conteúdo de cada página é
renderizado dentro HTML do arquivo de Layout.
Agora execute o aplicativo e exiba-o no navegador. Você pode executar o aplicativo usando Ctrl +F5 ou
escolhendo Debug > Star t Sem Depuração no menu do Visual Studio.
Personalizar o aplicativo
Adicione uma propriedade ao arquivo Index.cshtml.cs e defina seu valor para a hora atual no manipulador OnGet :
public string Time { get; set; }

public void OnGet()
{
Time = DateTime.Today.ToShortTimeString();
}
Substitua o conteúdo de <div> em Index.cshtml por esta marcação:
<h2>It's @Model.Time right now on the server!</h2>
Execute o aplicativo novamente. Você deve ver a página agora exibindo a hora atual, mas é sempre meia-noite!
Isso não está certo.
Depurar o aplicativo
Adicione um ponto de interrupção para o método OnGet no local em que estamos atribuindo um valor para
Time e, dessa vez, comece a depurar o aplicativo.
A execução é interrompida na linha e você pode ver que DateTime.Today inclui a data, mas a hora sempre é meia-
noite, porque ele não inclui dados de horário.
Altere-o para usar DateTime.Now e continue a executar. O novo código para OnGet deve ser:
public void OnGet()

{
Time = DateTime.Now.ToShortTimeString();
}
Agora você deve ver o tempo real do servidor no navegador quando você navega para o aplicativo.
NOTE
Sua saída pode diferir da imagem, já que o formato de saída de ToShortDateTimeString depende da configuração de cultura
atual. Consulte ToShortTimeString().
Próximas etapas
No próximo vídeo, você aprenderá como adicionar suporte a dados em seu aplicativo.
Tutorial: Trabalhando com dados no seu ASP.NET aplicativo principal
Confira também
Tutorial: Crie um aplicativo web Razor Pages com ASP.NET Core
Passo 3: Trabalhar com dados usando o Framework
entityentity
Siga estas etapas para começar a trabalhar com dados usando Entity Framework Core em seu aplicativo Web
ASP.NET Core.
Assista a este vídeo e siga as instruções para adicionar dados em seu primeiro aplicativo Web ASP.NET Core.
Abrir o projeto
Se você estiver acompanhando estes vídeos, abra o projeto de aplicativo Web que você criou na seção anterior. Se
você estiver começando, precisará criar um novo projeto e escolher Aplicativo Web ASP.NET e, em seguida,
aplicativo Web . Deixe o restante das opções com os padrões.
Adicionar o modelo
O primeiro a fazer para trabalhar com dados no aplicativo ASP.NET Core é descrever como devem ser os dados.
Chamamos essa criação de modelo dos elementos envolvidos no problema que estamos tentando resolver. Em
aplicativos reais, adicionaremos lógica de negócios personalizada nesses modelos para que possam se
comportam de determinadas maneiras e automatizar tarefas. Neste exemplo, vamos criar um sistema simples
para controlar jogos de tabuleiro. Precisamos de uma classe que represente um jogo e inclua algumas
propriedades que queremos registrar sobre esse jogo, por exemplo, a quantas pessoas ele pode dar suporte. Essa
classe entrará em uma nova pasta que criaremos na raiz do projeto da Web, chamada Modelos.
public class Game

{
public int Id { get; set; }
public string Title { get; set; }
public int PublicationYear { get; set; }
public int MinimumPlayers { get; set; }
public int MaximumPlayers { get; set; }
}
Criar as páginas para gerenciar sua biblioteca de jogos

Agora estamos prontos para criar as páginas que usaremos para gerenciar nossa biblioteca de jogos. Isso pode
parecer intimidador, mas é surpreendentemente fácil. Primeiro, precisamos decidir onde em nosso aplicativo essa
funcionalidade deve residir. Abra a pasta Páginas no projeto da Web e adicione uma nova pasta lá. Chame-a de
Jogos.
Agora clique com o botão direito do mouse em Jogos e escolha Adicionar > novo item de andaime . Escolha as
Razor Pages usando a opção Entity Framework (CRUD) . CRUD significa "Criar, ler, atualizar, excluir", e este
modelo criará páginas para cada uma dessas operações (incluindo uma página "Listar tudo" e uma página "Exibir
detalhes de um item").
Selecione sua classe de modelo Jogo e use o ícone “+” para adicionar uma nova classe de contexto de dados.
Nomeie-o AppDbContext . Mantenha os outros padrões e clique em Adicionar .
Você verá que as seguintes Razor Pages adicionadas à pasta Jogos:
Create.cshtml
Delete.cshtml
Details.cshtml
Edit.cshtml
Index.cshtml
Além de adicionar páginas na pasta Jogos, a operação de scaffolding adicionou código à minha classe Startup.cs.
Examinando o método ConfigureServices nessa classe, você verá que este código foi adicionado:
services.AddDbContext<AppDbContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("AppDbContext")));
Você também descobrirá que a cadeia de conexão AppDbContext foi adicionada ao arquivo appsettings.json do
projeto.
Se você executar o aplicativo agora, ele poderá falhar porque nenhum banco de dados foi criado ainda. Você pode
configurar o aplicativo para criar automaticamente o banco de dados, se for necessário ao adicionar código a
Program.cs:
public static void Main(string[] args)

{
var host = CreateWebHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())

{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService<AppDbContext>();
context.Database.EnsureCreated();
}
catch (Exception ex)
{
var logger = services.GetRequiredService<ILogger<Program>>();
logger.LogError(ex, "An error occurred creating the DB.");
}
}
host.Run();
}
Para resolver os typenames no código anterior, adicione as seguintes instruções using a Program.cs no final do
bloco existente de instruções using:
using Microsoft.Extensions.DependencyInjection;
using WebApplication1.Models;
Use o nome do seu projeto, em vez de WebApplication1 em seu código.

A maior parte do código é apenas para tratamento de erro e para fornecer acesso ao EF Core AppDbContext antes
que o aplicativo entre em execução. A linha importante é a que diz context.Database.EnsureCreated() , que criará o
banco de dados se ele ainda não existir. Agora, o aplicativo está pronto para ser executado.
Testar
Execute o aplicativo e navegue para /Games na barra de endereços. Você verá uma página de lista vazia. Selecione
Criar Novo para adicionar um novo Game à coleção. Preencha o formulário e clique em Criar . Você deve vê-lo
na exibição de lista. Clique em Detalhes para ver os detalhes de um único registro.
Adicione outro registro. Você pode clicar em Editar para alterar os detalhes de um registro ou em Excluir para
removê-lo, o que solicitará uma confirmação antes da exclusão do registro.
Isso é o necessário para começar a trabalhar com dados em um aplicativo ASP.NET Core usando EF Core e Visual
Studio 2019.
Próximas etapas
No próximo vídeo, você aprenderá como adicionar suporte à API Web em seu aplicativo.
Passo 4: Expor uma API web do seu ASP.NET aplicativo core
Confira também
Razor Pages com o Entity Framework Core no ASP.NET Core
Razor Pages do ASP.NET Core com EF Core
Passo 4: Exponha uma API web do seu aplicativo
ASP.NET Core
Siga estas etapas para adicionar uma API Web ao seu aplicativo ASP.NET Core existente.
Assista a este vídeo e acompanhe-o para adicionar suporte a API Web em seu primeiro aplicativo Web ASP.NET
Core.
Abrir o projeto
Abra seu aplicativo ASP.NET Core no Visual Studio 2019. O aplicativo deverá já estar usando o EF Core para
gerenciar seus tipos de modelo, conforme configurado na etapa 3 desta série de tutoriais.
Adicionar um controlador de API

Clique com o botão direito do mouse no projeto e adicione uma nova pasta chamada Api. Em seguida, clique com
o botão direito do mouse nesta pasta e escolha Adicionar > novo item de andaime . Escolha Controlador de
API com ações, usando o Entity Framework . Agora, escolha uma classe de modelo existente e clique em
Adicionar .
Examinar o controlador gerado

O código gerado inclui uma nova classe de controlador. Na parte superior da definição de classe há dois atributos.
[Route("api/[controller]")]
[ApiController]
public class GamesController : ControllerBase
O primeiro especifica a rota para ações nesse controlador como api/[controller] , o que significa que, se o
controlador for denominado GamesController , a rota será api/Games .
O segundo atributo, [ApiController] , adiciona algumas validações úteis à classe, como garantir que cada método
de ação inclua seu próprio atributo [Route] .
public class GamesController : ControllerBase

{
private readonly AppDbContext _context;
public GamesController(AppDbContext context)

{
_context = context;
}
O controlador usa o AppDbContext existente, passado para seu construtor. Cada ação usará esse campo para
trabalhar com os dados do aplicativo.
// GET: api/Games
[HttpGet]
public IEnumerable<Game> GetGame()
{
return _context.Game;
}
O primeiro método é uma solicitação GET simples, como especificado usando o atributo [HttpGet] . Ele não usa
nenhum parâmetro e retorna uma lista de todos os jogos no banco de dados.
// GET: api/Games/5
[HttpGet("{id}")]
public async Task<IActionResult> GetGame([FromRoute] int id)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
var game = await _context.Game.FindAsync(id);
if (game == null)
{
return NotFound();
}
return Ok(game);
}
O próximo método especifica {id} na rota, o que será adicionado à rota após um / , para que a rota completa
seja algo como api/Games/5 , conforme mostrado no comentário na parte superior. A entrada id é mapeada para
o parâmetro id no método. Dentro do método, se o modelo for inválido, um resultado BadRequest será
retornado. Caso contrário, o EF tentará encontrar o registro correspondente ao id fornecido. Se não for possível,
um resultado NotFound será retornado, caso contrário, o registro Game apropriado será retornado.
// PUT: api/Games/5
[HttpPut("{id}")]
public async Task<IActionResult> PutGame([FromRoute] int id, [FromBody] Game game)
{
{
}
if (id != game.Id)
{
return BadRequest();
}
_context.Entry(game).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!GameExists(id))
{
return NotFound();
}
else
{
throw;
}
}
return NoContent();
}
Em seguida, uma solicitação [HttpPut] feita à API é usada para realizar atualizações. O novo registro Game é
fornecido no corpo da solicitação. Algumas verificações de validação e erro são executadas e, se tudo for bem-
sucedido, o registro no banco de dados será atualizado com os valores fornecidos no corpo da solicitação. Caso
contrário, uma resposta de erro apropriada será retornada.
// POST: api/Games
[HttpPost]
public async Task<IActionResult> PostGame([FromBody] Game game)
{
{
}
_context.Game.Add(game);
return CreatedAtAction("GetGame", new { id = game.Id }, game);

}
Uma solicitação [HttpPost] é usada para adicionar novos registros ao sistema. Assim como acontece com o
[HttpPut] , o registro é adicionado no corpo da solicitação. Se ele for válido, o EF Core adicionará o registro ao
banco de dados, e a ação retornará o registro atualizado (com sua ID do banco de dados gerada) e um link para o
registro na API.
// DELETE: api/Games/5
[HttpDelete("{id}")]
public async Task<IActionResult> DeleteGame([FromRoute] int id)
{
{
}
var game = await _context.Game.FindAsync(id);

if (game == null)
{
return NotFound();
}
_context.Game.Remove(game);
return Ok(game);
}
Por fim, uma rota [HttpDelete] é usada com uma ID para excluir um registro. Se a solicitação for válida e existir
um registro com a ID especificada, o EF Core o excluirá do banco de dados.
Adicionar o Swagger
O Swagger é uma ferramenta de documentação e testes da API que pode ser adicionada como um conjunto de
serviços e middleware a um aplicativo ASP.NET Core. Para isso, clique com o botão direito do mouse no projeto e
escolha Gerenciar pacotes NuGet . Em seguida, clique Swashbuckle.AspNetCore em Procurar , procurar e instalar
a versão 4.0.1.
Uma vez instalado, abra Startup.cs e adicione o seguinte ao final do método ConfigureServices :
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Info { Title = "My API", Version = "v1" });
});
Também é preciso adicionar using Swashbuckle.AspNetCore.Swagger; ao início do arquivo.

Em seguida, adicione o seguinte método Configure , antes de UseMvc :
// Enable middleware to serve generated Swagger as a JSON endpoint.
app.UseSwagger();
// Enable middleware to serve swagger-ui (HTML, JS, CSS, etc.),

// specifying the Swagger JSON endpoint.
app.UseSwaggerUI(c =>
{
c.SwaggerEndpoint("/swagger/v1/swagger.json", "My API V1");
});
Agora você pode compilar e executar seu aplicativo. No navegador, vá até /swagger na barra de endereços. Você
deve ver uma lista de modelos e pontos de extremidade de API do seu aplicativo.
Clique em um ponto de extremidade em Jogos, depois em Try it out e Execute para ver como os diferentes
pontos de extremidade se comportam.
Próximas etapas
No próximo vídeo, você aprenderá como implantar seu aplicativo no Azure.
Passo 5: Implantar seu ASP.NET aplicativo principal para o Azure
Confira também
Introdução ao Swashbuckle e ao ASP.NET Core
ASP.NET páginas de ajuda da Web API com Swagger / OpenAPI
Passo 5: Implante seu aplicativo ASP.NET Core para o
Azure
Siga estas etapas para implantar seu aplicativo ASP.NET Core e seu banco de dados no Azure.
Assista a este vídeo e acompanhe-o para implantar primeiro aplicativo Web ASP.NET Core no Azure.
Abrir o projeto
Abra seu aplicativo ASP.NET Core no Visual Studio 2019. O aplicativo já deve estar usando a configuração com o EF
Core e uma API Web ativa, conforme configurado na etapa 4 desta série de tutoriais.
Publicar no Serviço de Aplicativo do Azure

Clique com o botão direito do mouse no projeto no gerenciador de soluções e escolha Publicar . Mantenha as
configurações padrão do Ser viço de Aplicativo e Criar Novo e clique no botão Publicar . Se você ainda não
tiver uma conta do Azure, clique em Criar sua conta gratuita do Azure e conclua o breve processo de registro.
Adicione um SQL Server. Especifique um nome de usuário e senha de administrador.
Adicione Application Insights.

Clique no botão Criar para continuar.
Explorar o portal do Azure e seu aplicativo hospedado
Depois que o serviço de aplicativo for criado, seu site será iniciado em um navegador. Durante o carregamento,
você também pode encontrar o Serviço de Aplicativo no portal do Azure. Ao explorar as opções disponíveis para o
serviço de aplicativo, você encontrará uma seção de Visão Geral em que é possível iniciar e interromper o
aplicativo.
Escalabilidade
Você pode examinar as opções para dimensionar o aplicativo, bem como para fora. O dimensionamento refere-se
ao aumento dos recursos dados a cada instância que hospeda seu aplicativo. Escalar horizontalmente refere-se ao
aumento do número de instâncias que hospedam seu aplicativo. Você pode configurar o dimensionamento
automático para seu aplicativo, o que aumenta automaticamente o número de instâncias usadas para hospedar
seu aplicativo em resposta ao carregamento, depois as reduz quando a carga diminuiu.
Segurança e conformidade
Outro benefício de hospedar o aplicativo usando o Azure é a segurança e conformidade. O Serviço de Aplicativo
do Azure fornece conformidade com PCI, SOC e ISO. Podemos autenticar usuários com o Azure Active Directory ou
logons sociais, como o Twitter, Facebook, Google ou Microsoft. Podemos criar restrições de IP, gerenciar
identidades de serviço, adicionar domínios personalizados e oferecer suporte a SSL para o aplicativo, além de
configurar backups com cópias de arquivos mortos restauráveis do conteúdo, da configuração e do banco de
dados do aplicativo. Esses recursos são acessados nas opções de menu Autenticação/Autorização, Identidade,
Backups e Configurações de SSL.
Slots de implantação
Geralmente, quando você implanta um aplicativo, há um pequeno tempo de inatividade enquanto o aplicativo é
reiniciado. Os slots de implantação evitam esse problema, permitindo a implantação em uma instância de preparo
separada ou em um conjunto de instâncias, fazendo a preparação antes de colocá-las em produção. A troca é
apenas um redirecionamento do tráfego instantâneo e sem problemas. Se houver algum problema na produção
após a troca, você poderá reverter a troca para seu último estado de boa produção conhecido.
Atualizar cadeia de conexão

Por padrão, o Azure espera que a conexão de um novo aplicativo ao seu novo banco de dados do SQL Server use
uma cadeia de conexão chamada DefaultConnection . No momento, o aplicativo criado anteriormente nesta série
de tutoriais usa uma cadeia de conexão chamada AppDbContext . Precisamos alterar isso em appsettings.json e
Startup.cs, depois reimplantar o aplicativo.
Testar o aplicativo em execução no Azure

Navegue até o caminho /Jogos para adicionar um novo jogo e vê-lo listado. Em seguida, navegue até o caminho
/swagger para usar os pontos de extremidade da API Web a partir dali, para confirmar que a API do aplicativo está
funcionando bem.
Parabéns! Você concluiu esta série de tutoriais em vídeo!
Próximas etapas
Saiba mais sobre como projetar aplicativos ASP.NET Core com esses recursos gratuitos.
Arquitetura do aplicativo ASP.NET Core
Confira também
Publicar um aplicativo ASP.NET Core no Azure com o Visual Studio
Como: Executar um programa C# no Visual Studio
O que você precisa fazer para executar um programa depende do que você está começando, que tipo de programa,
aplicativo ou serviço é, e se você quer executá-lo sob o depurador ou não. No caso mais simples, quando você tiver
um projeto aberto no Visual Studio, construa e execute-o pressionando Ctrl +F5 (Iniciar sem depuração) ou F5
(Comece com a depuração), ou pressione o arqueiro verde (Botão de Par tida) na barra de ferramentas
principal do Visual Studio.
A partir de um projeto
Se você tem um projeto C# (arquivo .csproj), então você pode executá-lo, se for um programa executável. Se um
projeto contiver um Main arquivo C# com um método, e sua saída for um EXE executável, então provavelmente ele
será executado se for construído com sucesso.
Se você já tem o código para o seu programa em um projeto no Visual Studio, abra o projeto. Para abrir o projeto,
clique duas vezes ou toque no .csproj do Windows File Explorer ou no Visual Studio, escolha Abrir um projeto,
procurar encontrar o arquivo project (.csproj) e escolher o arquivo do projeto.
Após as cargas dos projetos no Visual Studio, pressione Ctrl +F5 (Iniciar sem depuração) ou use o botão verde
Iniciar na barra de ferramentas do Visual Studio para executar o programa. Se houver vários projetos, aquele Main
com o método deve ser definido como o projeto de inicialização. Para definir o projeto de inicialização, clique com
o botão direito do mouse em um nó de projeto e escolha Definir como projeto de inicialização .
O Visual Studio tenta construir e executar seu projeto. Se houver erros de compilação, você verá a saída de
compilação na janela Saída e os erros na janela Lista de erros.
Se a compilação for bem sucedida, o aplicativo será executado de uma forma apropriada para o tipo de projeto.
Aplicativos de console são executados em uma janela de terminal, aplicativos de desktop do Windows começam
em uma nova janela, os aplicativos da Web começam no navegador (hospedado pelo IIS Express), e assim por
diante.
A partir do código
Se você está começando a partir de uma listagem de código, arquivo de código ou um pequeno número de
arquivos, primeiro certifique-se de que o código que você deseja executar é de uma fonte confiável e é um
programa executável. Se ele Main tiver um método, provavelmente é destinado como um programa executável
que você pode usar o modelo console App para criar um projeto para trabalhar com ele no Visual Studio.
Listagem de código para um único arquivo
Inicie o Visual Studio, abra um projeto de console C# vazio, selecione todo o código no arquivo .cs que já está no
projeto e exclua-o. Em seguida, cole o conteúdo do seu código no arquivo .cs. Quando você colar o código,
sobrepor ou excluir o código que estava lá antes. Renomeie o arquivo para corresponder ao código original.
Listas de código para alguns arquivos
Inicie o Visual Studio, abra um projeto de console C# vazio, selecione todo o código no arquivo .cs que já está no
projeto e exclua-o. Em seguida, cole o conteúdo do primeiro arquivo de código no arquivo .cs. Renomeie o arquivo
para corresponder ao código original.
Para um segundo arquivo, clique com o botão direito do mouse no nó do projeto no Solution Explorer para abrir
o menu de atalho para o projeto e escolha Adicionar > Item Existente (ou use a combinação de teclas
Shift +Alt +A), e selecione os arquivos de código.
Vários arquivos em disco
1. Crie um novo projeto do tipo apropriado (use C# Console App, se você não tiver certeza).
2. Clique com o botão direito do mouse no nó do projeto, se Adicionar > item existente para selecionar os
arquivos e importá-los para o seu projeto.
A partir de uma pasta
Quando você estiver trabalhando com uma pasta de muitos arquivos, primeiro veja se há um projeto ou solução. Se
o programa foi criado com o Visual Studio, você deve encontrar um arquivo de projeto ou um arquivo de solução.
Procure arquivos com a extensão .csproj ou extensão .sln e no Windows File Explorer, clique duas vezes em um
deles para abri-los no Visual Studio. Consulte A partir de uma solução ou projeto do Visual Studio.
Se você não tiver um arquivo de projeto, como se o código foi desenvolvido em outro ambiente de
desenvolvimento, então abra a pasta de nível superior usando o método de pasta Aber ta no Visual Studio.
Consulte Desenvolver código sem projetos ou soluções.
A partir de um repo GitHub ou Azure DevOps

Se o código que você deseja executar estiver no GitHub ou em um repo Azure DevOps, você pode usar o Visual
Studio para abrir o projeto diretamente do repo. Consulte Abrir um projeto a partir de um repo.
Execute o programa
Para iniciar o programa, pressione o arqueiro verde (botãoIniciar) na barra de ferramentas principal do Visual
Studio ou pressione F5 ou Ctrl +F5 para executar o programa. Quando você usa o botão Iniciar, ele é executado
sob o depurador. O Visual Studio tenta construir o código em seu projeto e executá-lo. Se isso for bem sucedido,
ótimo! Mas se não, continue lendo algumas ideias sobre como fazê-lo construir com sucesso.
Solução de problemas
Seu código pode ter erros, mas se o código estiver correto, mas depender apenas de alguns outros conjuntos ou
pacotes NuGet, ou foi escrito para segmentar uma versão diferente do .NET, você pode ser capaz de corrigi-lo
facilmente.
Adicionar referências
Para construir corretamente, o código deve estar correto e ter as referências certas configuradas para bibliotecas
ou outras dependências. Você pode olhar para as linhas vermelhas e na Lista de erros para ver se o programa
tem algum erro, mesmo antes de compilar e executá-lo. Se você está vendo erros relacionados a nomes não
resolvidos, você provavelmente precisa adicionar uma referência ou uma diretiva de uso, ou ambos. Se o código
fizer referência a quaisquer conjuntos ou pacotes NuGet, você precisará adicionar essas referências no projeto.
O Visual Studio tenta ajudá-lo a identificar referências perdidas. Quando um nome não é resolvido, um ícone de
lâmpada aparece no editor. Se você clicar na lâmpada, você pode ver algumas sugestões sobre como corrigir o
problema. Correções podem ser:
adicionar uma diretiva de uso
adicionar uma referência a uma assembléia, ou
instalar um pacote NuGet.
Faltando usando diretiva
Por exemplo, na tela a seguir, using System; você pode optar por adicionar ao Console início do arquivo de código
para resolver o nome não resolvido:
Referência de montagem ausente

As referências .NET podem ser na forma de conjuntos ou pacotes NuGet. Normalmente, se você encontrar código
fonte, o editor ou autor explicará quais conjuntos são necessários e quais pacotes o código depende. Para adicionar
uma referência a um projeto manualmente, clique com o botão direito do mouse no nó Referências no
Explorador de soluções, escolha Adicionar referência e localize o conjunto necessário.
Você pode encontrar conjuntos e adicionar referências seguindo as instruções em Adicionar ou remover
referências usando o gerenciador de referências.
Pacote NuGet ausente
Se o Visual Studio detectar um pacote NuGet ausente, uma lâmpada aparecerá e lhe der a opção de instalá-lo:
Se isso não resolver o problema e o Visual Studio não conseguir localizar o pacote, tente procurá-lo online.
Consulte Instalar e usar um pacote NuGet no Visual Studio.
Use a versão certa do .NET

Como diferentes versões do .NET Framework têm algum grau de compatibilidade retrógrada, uma nova estrutura
pode executar código sumido para uma estrutura mais antiga sem quaisquer modificações. Mas, às vezes, você
precisa mirar em uma estrutura específica. Você pode precisar instalar uma versão específica do .NET Framework
ou .NET Core, se ele ainda não estiver instalado. Consulte Modify Visual Studio.
Para alterar o quadro de destino, consulte Alterar o quadro de destino. Para obter mais informações, consulte Erros
de segmentação do Framework .NET.
Próximas etapas
Explore o ambiente de desenvolvimento do Visual Studio lendo Welcome to the Visual Studio IDE.
Confira também
Crie seu primeiro aplicativo C#
Tutorial: Abra um projeto a partir de um repo
Neste tutorial, você usará o Visual Studio para se conectar a um repositório pela primeira vez e, em seguida, abrir
um projeto nele.
gratuitamente.
gratuitamente.
Abrir um projeto de um repositório GitHub

2. Na barra de menus superior, escolha Arquivo > Abrir > Abrir do Controle do Código-Fonte .
O painel Team Explorer – Conectar é aberto.
3. Na seção Repositórios Git Locais , escolha Clone .
4. Na caixa que diz Insira a URL de um repositório Git para clonar , digite ou cole a URL do seu
repositório e pressione Enter . (Talvez você veja um prompt para entrar no GitHub; caso ocorra, entre).
Depois que o Visual Studio clona o repositório, o Team Explorer é fechado e o Gerenciador de Soluções é
aberto. É exibida uma mensagem que diz Clique em Soluções e Pastas acima para exibir uma lista de
Soluções. Escolha Soluções e Pastas .
5. Se houver um arquivo de solução disponível, ele será exibido no menu suspenso "Soluções e Pastas".
Escolha-o, e o Visual Studio abrirá sua solução.
Se você não tiver um arquivo de solução (especificamente, um arquivo .sln) no seu repositório, o menu
suspenso mostrará a mensagem "Nenhuma solução encontrada". No entanto, você pode clicar duas vezes
em qualquer arquivo no menu de pastas para abri-lo no editor de códigos do Visual Studio.
Examinar seu trabalho
Exiba a animação a seguir para verificar o trabalho que você concluiu a seção anterior.
2. Na janela de início, escolha Clonar ou verificar código .
3. Insira ou digite a localização do repositório e, em seguida, escolha Clonar .

O Visual Studio abre o projeto do repositório.
4. Se houver um arquivo de solução disponível, ele será exibido no menu suspenso "Soluções e Pastas".
Escolha-o, e o Visual Studio abrirá sua solução.
Se você não tiver um arquivo de solução (especificamente, um arquivo .sln) no seu repositório, o menu
suspenso mostrará a mensagem "Nenhuma solução encontrada". No entanto, você pode clicar duas vezes
em qualquer arquivo no menu de pastas para abri-lo no editor de códigos do Visual Studio.
Abrir um projeto de um repositório Azure DevOps

2. Na barra de menus superior, escolha Arquivo > Abrir > Abrir do Controle do Código-Fonte .
O painel Team Explorer – Conectar é aberto.
3. Há duas maneiras de se conectar ao repositório Azure DevOps:

Na seção Provedores de Ser viços Hospedados , escolha **Conectar... **.
Na lista suspensa Gerenciar Conexões , escolha Conectar-se a um Projeto....

4. Na caixa de diálogo Conectar-se a um Projeto , escolha o repositório a que você deseja se conectar e
escolha Clone .
NOTE
O que é exibido na caixa de listagem depende dos repositórios Azure DevOps a que você tem acesso.
5. Depois que o Visual Studio clona o repositório, o Team Explorer é fechado e o Gerenciador de Soluções é
aberto. É exibida uma mensagem que diz Clique em Soluções e Pastas acima para exibir uma lista de
Soluções. Escolha Soluções e Pastas .
Um arquivo de solução (especificamente, um arquivo .sln) será exibido no menu suspenso "Soluções e
Pastas". Escolha-o, e o Visual Studio abrirá sua solução.
Se você não tiver um arquivo de solução no seu repositório, o menu suspenso mostrará a mensagem
"Nenhuma solução encontrada". No entanto, você pode clicar duas vezes em qualquer arquivo no menu de
pastas para abri-lo no editor de códigos do Visual Studio.
2. Na janela de início, escolha Clonar ou verificar código .
3. Na seção Navegar em um repositório , escolha Azure DevOps .

Se você vir uma janela de entrada, entre em sua conta.
4. Na caixa de diálogo Conectar-se a um Projeto , escolha o repositório a que você deseja se conectar e
escolha Clone .
NOTE
O que é exibido na caixa de listagem depende dos repositórios Azure DevOps a que você tem acesso.
O Visual Studio abrirá o Team Explorer e uma notificação será exibida quando a clonagem for concluída.
5. Para exibir pastas e arquivos, escolha o link Mostrar Exibição de Pasta .
O Visual Studio abre o Gerenciador de Soluções .

6. Escolha o link Soluções e Pastas para procurar um arquivo de solução (especificamente, um arquivo .sln)
para abrir.
Se você não tiver um arquivo de solução no seu repositório, a mensagem "Nenhuma Solução Encontrada"
aparecerá. No entanto, você pode clicar duas vezes em qualquer arquivo no menu de pastas para abri-lo no
editor de códigos do Visual Studio.
Próximas etapas
Se estiver pronto para codificar com o Visual Studio, aprofunde-se em qualquer um dos seguintes tutoriais
específicos a um idioma:
Tutoriais do Visual Studio | C#
Tutoriais do Visual Studio | Visual Basic
Tutoriais do Visual Studio | C++
Tutoriais do Visual Studio | Python
Tutoriais do Visual Studio | JavaScript , TypeScript e Node.js
Confira também
Serviços Azure DevOps: Comece com a Azure Repos e o Visual Studio
Microsoft Learn: Comece com o Azure DevOps
Nesta introdução de 10 minutos ao editor de código do Visual Studio, adicionaremos o código a um arquivo para
ver algumas das formas pelas quais o Visual Studio facilita a escrita, a navegação e o entendimento do código.
TIP
TIP
Este artigo pressupõe que você já esteja familiarizado com o C#. Caso contrário, sugerimos que você primeiro
examine um tutorial, como Introdução ao C# e ao ASP.NET Core no Visual Studio.
TIP
Para acompanhar este artigo, verifique se você tem as configurações do C# selecionadas para o Visual Studio. Para obter
informações sobre como selecionar configurações para o IDE (ambiente de desenvolvimento integrado), confira Selecionar
configurações de ambiente.
Criar um novo arquivo de código

Comece criando um novo arquivo e adicionando códigos nele.
1. Abra o Visual Studio. Pressione Esc ou clique em Continuar sem código na janela de início para abrir o
ambiente de desenvolvimento.
2. No menu Arquivo na barra de menu, escolha Arquivo Novo > ou pressione Ctrl +N .
3. Na caixa de diálogo Novo Arquivo , na categoria Geral , escolha Classe do Visual C# e, então, selecione
Abrir .
Um novo arquivo é aberto no editor com o esqueleto de uma classe de C#. (Observe que não precisamos
criar um projeto completo do Visual Studio para obter alguns dos benefícios que o editor de códigos
oferece; basta ter um arquivo de código!)
Usar snippets de código
O Visual Studio fornece snippets de código úteis que você pode usar para gerar os blocos de código usados com
frequência de forma rápida e fácil. Os snippets de código estão disponíveis para linguagens de programação
diferentes, incluindo C#, Visual Basic e C++. Vamos adicionar o snippet void Main de C# em nosso arquivo.
1. Coloque o cursor logo acima } da cinta de fechamento svm final } static void Main —no arquivo e digite
os caracteres (o que significa não se preocupe muito se você não sabe o que isso significa).
Uma caixa de diálogo pop-up é exibida com informações sobre o snippet de código svm .
2. Pressione a Guia duas vezes para inserir o snippet de código.

Você verá que a assinatura do método static void Main() será adicionada ao arquivo. O método Main() é
o ponto de entrada para aplicativos C#.
Os snippets de código disponíveis variam em linguagens de programação diferentes. Você pode olhar os trechos
de código disponíveis para o seu idioma escolhendo Editar > intesteja > o Snippet ou pressionando Ctrl +K ,
Ctrl +X e, em seguida, escolhendo a pasta do seu idioma. Para o C#, a lista tem este aspecto:
A lista inclui snippets para a criação de uma classe, um construtor, um loop for, uma instrução if ou switch e muito
mais.
Comentar o código
A barra de ferramentas, que é a linha de botões sob a barra de menus no Visual Studio, pode ajudar a aumentar
sua produtividade durante a codificação. Por exemplo, você pode alternar o modo de preenchimento do
IntelliSense (o IntelliSense é um recurso de codificação que exibe uma lista de correspondência de métodos, entre
outras coisas), aumentar ou diminuir um recuo de linha ou comentar um código que você não deseja compilar.
Nesta seção, comentaremos alguns códigos.
1. Cole o código a seguir no corpo do método Main() .
// _words is a string array that we'll sort alphabetically

string[] _words = {
"the",
"quick",
"brown",
"fox",
"jumps"
};
string[] morewords = {
"over",
"the",
"lazy",
"dog"
};
IEnumerable<string> query = from word in _words

orderby word.Length
select word;
2. Não estamos usando a variável morewords , mas podemos usá-la mais tarde. Portanto, não queremos excluí-
la por completo. Em vez disso, vamos comentar as linhas. Selecione a definição inteira de morewords até o
ponto e vírgula de fechamento e, em seguida, escolha o botão Comentar as linhas selecionadas na
barra de ferramentas. Se preferir usar o teclado, pressione Ctrl +K, Ctrl +C .
Os caracteres de comentários // de C# são adicionados ao início de cada linha selecionada para comentar
o código.
Recolher blocos de código

Não queremos ver o construtor vazio para Class1 que foi gerado. Portanto, para desobstruir nossa exibição do
código, vamos recolhê-la. Escolha a pequena caixa cinza com o sinal de subtração dentro da margem da primeira
linha do construtor. Ou, se você é um usuário de teclado, coloque o cursor em qualquer lugar no código do
construtor e pressione Ctrl +M , Ctrl +M .
O bloco de código é recolhido apenas na primeira linha, seguido por um sinal de reticências ( ... ). Para expandir
o bloco de código novamente, clique na mesma caixa cinza que agora tem um sinal de mais nele, ou pressione
Ctrl +M , Ctrl +M novamente. Este recurso é chamado de Delineamento e é especialmente útil quando você está
colapsando métodos longos ou classes inteiras.
Exibir definições de símbolo

O editor do Visual Studio facilita a inspeção da definição de um tipo, método, etc. Uma maneira é navegar até o
arquivo que contém a definição, por exemplo, escolhendo Ir para Definição ou pressionando F12 em qualquer
lugar que o símbolo seja referenciado. Uma maneira ainda mais rápida que não move o foco para fora do arquivo
em que você está trabalhando é usar a opção Inspecionar Definição. Vamos espiar a definição do tipo string .
1. Clique com o botão direito do mouse em qualquer ocorrência de string e escolha Espiar Definição no
menu de conteúdo. Ou, pressione Alt +F12 .
Uma janela pop-up será exibida com a definição da classe String . Você pode rolar na janela pop-up ou até
mesmo inspecionar a definição de outro tipo do código inspecionado.
2. Feche a janela de definição inspecionada ao selecionar a caixa pequena com um “x” no canto superior
direito da janela pop-up.
Usar o IntelliSense para completar palavras

O IntelliSense é um recurso inestimável quando você está codificando. Ele pode mostrar informações sobre
membros disponíveis de um tipo ou detalhes de parâmetros para sobrecargas diferentes de um método. Você
também pode usar o IntelliSense para completar uma palavra depois que você digitar caracteres suficientes para
desambiguá-la. Vamos adicionar uma linha de código para imprimir as cadeias de caracteres ordenadas na janela
de console, que é o local padrão para envio da saída do programa.
1. Abaixo da variável query , comece a digitar o código a seguir:
foreach (string str in qu
Você verá o IntelliSense mostrar as Informações Rápidas sobre o símbolo query .
2. Para inserir o restante da palavra query usando a funcionalidade de preenchimento de palavras do

IntelliSense, pressione Tab .
3. Finalize o bloco de código para que ele se pareça com o seguinte código. Você mesmo pode praticar usando
os snippets de código novamente ao inserir cw e, então, pressionar a Guia duas vezes para gerar o código
Console.WriteLine .
foreach (string str in query)

{
Console.WriteLine(str);
}
Refatorar um nome
Ninguém obtém o código correto na primeira vez e uma das coisas que talvez você precise alterar é o nome de
uma variável ou de um método. Vamos experimentar a funcionalidade de refatorar do Visual Studio para
renomear a variável _words como words .
1. Coloque o cursor sobre _words a definição da variável e escolha Renomear no menu de clique siou ou
contexto, ou pressione Ctrl +R, Ctrl +R .
Uma caixa de diálogo pop-up chamada Renomear aparecerá no canto superior direito do editor.
2. Insira o nome desejado words . Observe que a referência ao words na consulta também será renomeada
automaticamente. Antes de pressionar Enter , marque a caixa de seleção Incluir Comentários na caixa
pop-up Renomear .
3. Pressione Enter .
As duas ocorrências de words foram renomeadas, bem como a referência ao words do comentário de
código.
Próximas etapas
Confira também
Snippets de código
Navegue pelos códigos
Estrutura de tópicos
Ir para Definição e Definição de Pico
Refatoração
Usar o IntelliSense
Compilar e criar no Visual Studio
Para uma primeira introdução à construção dentro do IDE, consulte Passo a Passo: Construindo um aplicativo.
Você pode usar qualquer um dos métodos a seguir para compilar um aplicativo: o IDE do Visual Studio, as
ferramentas de linha de comando do MSBuild, e o Azure Pipelines:
M ÉTO DO DE B UIL D B EN EF ÍC IO S
IDE – Criar compilações imediatamente e testá-las em um

depurador.
– Executar builds em multiprocessador para projetos C++ e
C#.
– Personalizar diferentes aspectos do sistema de build.
CMake - Construir projetos usando a ferramenta CMake

- Use o mesmo sistema de compilação em plataformas Linux e
Windows.
Linha de comando do MSBuild – Criar projetos sem instalar o Visual Studio.

– Executar builds em multiprocessador para todos os tipos de
projeto.
– Personalizar a maioria das áreas do sistema de build.
Azure Pipelines – Automatizar o processo de build como parte de um pipeline

de integração contínua/entrega contínua.
– Aplicar testes automatizados com cada compilação.
– Empregar recursos baseados em nuvem praticamente
ilimitados para processos de build.
– Modificar o fluxo de trabalho de compilação e, conforme
necessário, criar atividades de compilação para realizar tarefas
profundamente personalizadas.
A documentação nesta seção detalha mais o processo de compilação baseado no IDE. Para obter mais informações
sobre os outros métodos, confira MSBuild e Azure Pipelines, respectivamente.
NOTE
Este tópico aplica-se ao Visual Studio no Windows. Para o Visual Studio para Mac, confira Compilar e criar no Visual Studio
para Mac.
Visão geral da compilação no IDE

Quando você cria um projeto, o Visual Studio cria configurações de compilação padrão para o projeto e para a
solução que contém o projeto. Essas configurações definem a maneira como as soluções e os projetos são criados e
implantados. Configurações de projeto, em particular, são exclusivas a uma plataforma de destino (por exemplo, o
Windows ou Linux) e tipo de build (por exemplo, depuração ou lançamento). Você pode editar essas configurações
como quiser e também pode criar suas próprias configurações, conforme necessário.
Para uma primeira introdução à construção dentro do IDE, consulte Passo a Passo: Construindo um aplicativo.
Em seguida, consulte Compilando e limpando projetos e soluções no Visual Studio para saber mais sobre as
personalizações de diferentes aspectos que você pode fazer no processo. As personalizações incluem alterar
diretórios de saída, especificar eventos de build personalizados, gerenciar dependências do projeto, gerenciar
arquivos de log de build e suprimir avisos do compilador.
A partir daí, você pode explorar uma variedade de outras tarefas:
Compreender configurações de build
Compreender plataformas de build
Gerenciar propriedades de projeto e solução.
Especificar eventos de build em C# e Visual Basic.
Definir opções de build
Construa vários projetos em paralelo.
Confira também
Criar (compilar) projetos de site
Compilar e criar (Visual Studio para Mac)
Projetos CMake no Visual Studio
Tutorial: aprenda a depurar código C# usando o
Visual Studio
Este artigo apresenta os recursos do depurador do Visual Studio passo a passo. Caso deseje obter uma exibição de
nível superior das funcionalidades do depurador, confira Introdução ao depurador. Quando você depura seu
aplicativo, isso normalmente significa executar o aplicativo com o depurador anexado. Quando você faz isso, o
depurador fornece várias maneiras de mostrar o que o código está fazendo enquanto é executado. Você pode
percorrer o código e examinar os valores armazenados em variáveis, definir inspeções em variáveis para ver
quando os valores mudam, examinar o caminho de execução do código, ver se um branch de código está em
execução e assim por diante. Se esta for sua primeira tentativa de depurar um código, leia Como depurar para
iniciantes absolutos antes continuar neste artigo.
Embora o aplicativo de demonstração esteja em C#, a maioria dos recursos são aplicáveis a C++, Visual Basic, F#,
Python, JavaScript e outras linguagens compatíveis com o Visual Studio (o F# não é compatível com editar e
continuar). F# e JavaScript não dão suporte à janela Autos ). As capturas de tela estão em C#.
Neste tutorial, você irá:
Iniciar o depurador e atingir os pontos de interrupção.
Aprender os comandos para percorrer o código no depurador
Inspecionar variáveis em dicas de dados e janelas do depurador
Examinar a pilha de chamadas
Pré-requisitos
Você deve ter o Visual Studio 2019 instalado e a carga de trabalho de desenvolvimento de plataforma
cruzada do .NET Core .
Você deve ter o Visual Studio 2017 instalado e a carga de trabalho de desenvolvimento de plataforma
cruzada do .NET Core .
gratuitamente.
gratuitamente.
Se você precisar instalar a carga de trabalho, mas já tiver o Visual Studio, vá para ferramentas > obter
ferramentas e recursos..., que abre o instalador do Visual Studio. O Instalador do Visual Studio é iniciado.
Escolha a carga de trabalho de desenvolvimento de plataforma cruzada do .NET Core e, em seguida, escolha
Modificar .
Criar um projeto
Primeiro, você criará um projeto de aplicativo de console do .NET Core. O tipo de projeto inclui todos os arquivos
de modelo que você precisará, mesmo sem adicionar nada!
2. Na barra de menus superior, escolha arquivo > novo > projeto .
3. Na caixa de diálogo Novo Projeto no painel esquerdo, expanda C# e escolha .NET Core . No painel central,
escolha Aplicativo de Console (.NET Core) . Em seguida, nomeie o projeto de introdução à depuração.
Se você não vir o modelo de projeto do Aplicativo de Console (.NET Core) , escolha o link Abrir
Instalador do Visual Studio no painel esquerdo da caixa de diálogo Novo Projeto .
O Instalador do Visual Studio é iniciado. Escolha a carga de trabalho Desenvolvimento multiplaforma
do .NET Core e, em seguida, selecione Modificar .
Se a janela iniciar não estiver aberta, escolha arquivo > Iniciar janela .
2. Na janela iniciar, escolha criar um novo projeto .
3. Na janela Criar um novo projeto , insira ou digite console na caixa de pesquisa. Em seguida, escolha C# na
lista Linguagem de programação e, em seguida, escolha Windows na lista Plataforma.
Depois de aplicar os filtros de linguagem de programação e plataforma, escolha o modelo Aplicativo de
Console (.NET Core) e, em seguida, escolha Avançar .
NOTE
Se não vir o modelo Aplicativo de Console (.NET Core) , você poderá instalá-lo da janela Criar um novo
projeto . Na mensagem Não encontrou o que precisa? , escolha o link Instalar mais ferramentas e recursos .
Em seguida, no Instalador do Visual Studio, escolha a carga de trabalho de desenvolvimento multiplataforma do
.NET Core .
4. Na janela configurar seu novo projeto , digite ou insira GetStartedDebugging na caixa nome do
projeto . Em seguida, escolha criar .
Criar o aplicativo
1. No Program.cs, substitua todo o código padrão pelo código a seguir, em vez disso:
using System;
class ArrayExample
{
static void Main()
{
char[] letters = { 'f', 'r', 'e', 'd', ' ', 's', 'm', 'i', 't', 'h'};
string name = "";
int[] a = new int[10];
for (int i = 0; i < letters.Length; i++)
{
name += letters[i];
a[i] = i + 1;
SendMessage(name, a[i]);
}
Console.ReadKey();
}
static void SendMessage(string name, int msg)
{
Console.WriteLine("Hello, " + name + "! Count to " + msg);
}
}
Inicie o depurador.
1. Pressione F5 (debug > iniciar depuração ) ou o botão Iniciar Depuração na barra de ferramentas
Depurar.
F5 inicia o aplicativo com o depurador anexado ao processo do aplicativo, mas nós ainda não fizemos nada
de especial para examinar o código. Portanto, o aplicativo apenas é carregado e a saída do console é exibida.
Hello, f! Count to 1
Hello, fr! Count to 2
Hello, fre! Count to 3
Hello, fred! Count to 4
Hello, fred ! Count to 5
Hello, fred s! Count to 6
Hello, fred sm! Count to 7
Hello, fred smi! Count to 8
Hello, fred smit! Count to 9
Hello, fred smith! Count to 10
Neste tutorial, vamos analisar melhor esse aplicativo usando o depurador e analisar os recursos do
depurador.
2. Pare o depurador pressionando o botão vermelho parar (Shift + F5 ).
3. Na janela do console, pressione uma tecla para fechar a janela do console.
Definir um ponto de interrupção e iniciar o depurador

1. No loop for da função Main , defina um ponto de interrupção clicando na margem esquerda da seguinte
linha de código:
name += letters[i];
Um ponto de de círculo vermelho aparece onde você define o ponto de interrupção.

Os pontos de interrupção são um dos recursos mais básicos e essenciais da depuração confiável. Um ponto
de interrupção indica quando o Visual Studio deve suspender o código em execução para que você possa
examinar os valores das variáveis ou o comportamento de memória ou se uma ramificação de código está
sendo executada ou não.
2. Pressione F5 ou o botão Iniciar Depuração , o aplicativo é iniciado e o depurador é executado na linha
de código em que você define o ponto de interrupção.
A seta amarela representa a instrução na qual o depurador ficou em pausa, que também suspende a
execução do aplicativo no mesmo ponto (essa instrução ainda não foi executada).
Se o aplicativo ainda não estiver em execução, F5 iniciará o depurador e o interromperá no primeiro ponto
de interrupção. Caso contrário, F5 continuará executando o aplicativo até o próximo ponto de interrupção.
Os pontos de interrupção são um recurso útil quando você sabe qual linha ou seção de código deseja
examinar em detalhes. Para obter informações sobre os diferentes tipos de pontos de interrupção que você
pode definir, como pontos de interrupção condicionais, consulte usando pontos de interrupção.
Navegar pelo código e inspecionar dados usando dicas de dados

Geralmente, usamos atalhos de teclado aqui porque essa é uma boa maneira de executar o aplicativo rapidamente
no depurador (os comandos equivalentes, como os comandos de menu, são mostrados entre parênteses).
1. Enquanto estiver em pausa na name += letters[i] instrução, focalize a letters variável e você verá o valor
padrão, o valor do primeiro elemento na matriz,. char[10]
Os recursos que permitem que você inspecione variáveis são uns dos mais úteis do depurador e há
diferentes maneiras de fazer isso. Muitas vezes, ao tentar depurar um problema, você tenta descobrir se as
variáveis estão armazenando os valores que elas deveriam conter em um momento específico.
2. Expanda letters a variável para ver suas propriedades, que incluem todos os elementos que a variável
contém.
3. Em seguida, passe o name mouse sobre a variável e você verá seu valor atual, uma cadeia de caracteres
vazia.
4. Pressione F10 (ou escolha depurar > etapas ) duas vezes para avançar para a SendMessage chamada de
método e, em seguida, pressione F10 mais uma vez.
F10 avança o depurador para a próxima instrução sem passar para funções ou métodos no seu código de
aplicativo (o código ainda é executado). Ao pressionar F10 na chamada SendMessage do método, ignoramos
o código de implementação para SendMessage (que talvez não estejamos interessados no momento).
5. Pressione F10 (ou depure > Step Over as for etapas) algumas vezes para iterar várias vezes pelo loop,
pausando novamente no ponto de interrupção e passando o mouse name sobre a variável a cada vez para
verificar seu valor.
O valor da variável é alterado com cada iteração do for loop, mostrando valores de f , então fr fre , e
assim por diante. Para avançar o depurador por meio do loop mais rapidamente neste cenário, você pode
pressionar F5 (ou escolher depurar > continuar ) em vez disso, o que o avança para o ponto de
interrupção em vez da próxima instrução.
Muitas vezes, durante a depuração, você deseja uma maneira rápida de verificar valores de propriedade em
variáveis, para ver se eles estão armazenando os valores que você espera que armazenem. As dicas de
dados são uma boa maneira de fazer isso.
6. Enquanto ainda estiver em pausa no for loop no Main método, pressione F11 (ou escolha depurar >
etapa ) até que você pause na chamada do SendMessage método.
Você deve estar nesta linha de código:
SendMessage(name, a[i]);
7. Pressione F11 mais uma vez para entrar no SendMessage método.
O ponteiro amarelo avança para o SendMessage método.
F11 é o comando Inter vir , que avança a execução do aplicativo uma instrução por vez. F11 é uma boa
maneira de examinar o fluxo de execução com o máximo de detalhes. Por padrão, o depurador ignora as
partes do código que não são do usuário (se quiser saber mais detalhes, confira Apenas Meu Código).
Digamos que você concluiu a análise do SendMessage método e deseja sair do método, mas permanecerá
no depurador. Você pode fazer isso usando o comando Depuração Circular .
8. Pressione Shift + F11 (ou debug > Step Out ).
Esse comando retoma a execução do aplicativo (e avança o depurador) até que o método ou a função atual
retorne.
Você deve estar de volta no for loop no Main método, em pausa na chamada do SendMessage método.
Para obter mais informações sobre diferentes maneiras de se mover pelo seu código, consulte navegar no
código no depurador.
Navegar usando Executar até o Clique

1. Pressione F5 para avançar para o ponto de interrupção novamente.
2. No editor de código, role para baixo e focalize o Console.WriteLine método no SendMessage método até
que a execução verde clique no botão em aparecer à esquerda. A dica de ferramenta para o botão
mostra "Realizar a execução até aqui".
NOTE
O botão Executar até o Clique é novo no Visual Studio 2017. (Se você não vir o botão de seta verde, use F11
neste exemplo em vez de avançar o depurador para o lugar certo.)
3. Clique no botão Executar para clicar em .

O depurador avança para o Console.WriteLine método.
O uso desse botão é semelhante à configuração de um ponto de interrupção temporário. Executar até o
Clique é útil para abranger rapidamente uma região visível do código do aplicativo (você pode clicar em
qualquer arquivo aberto).
Reinicie o aplicativo rapidamente

Clique no botão reiniciar na barra de ferramentas depurar (Ctrl + Shift + F5 ).
Ao pressionar Reiniciar , você economiza tempo em comparação com a opção de parar o aplicativo e reiniciar o
depurador. O depurador é pausado no primeiro ponto de interrupção que é atingido pela execução do código.
O depurador para novamente no ponto de interrupção que você definiu for anteriormente dentro do loop.
Inspecionar variáveis com as janelas Autos e Locais

1. Examine a janela Autos na parte inferior do editor de códigos.
Se ele estiver fechado, abra-o enquanto estiver em pausa no depurador escolhendo depurar > janelas >
automáticas .
Na janela Autos , veja as variáveis e seus valores atuais. A janela Autos mostra todas as variáveis usadas na
linha atual ou a linha anterior (verifique a documentação para saber o comportamento específico a uma
linguagem).
2. Em seguida, examine a janela Locais , em uma guia ao lado da janela Autos .
3. Expanda letters a variável para mostrar os elementos que ela contém.
A janela Locais mostra as variáveis que estão no escopo atual, ou seja, o contexto de execução atual.
Definir uma inspeção

1. Na janela principal do editor de código, clique com o name botão direito do mouse na variável e escolha
Adicionar inspeção .
A janela Inspeção é aberta na parte inferior do editor de códigos. Você pode usar uma janela Inspeção
para especificar uma variável (ou uma expressão) que deseja acompanhar.
Agora, você tem um observador definido na name variável e pode ver seu valor alterado à medida que
percorre o depurador. Ao contrário das outras janelas de variáveis, a janela Inspeção sempre mostra as
variáveis que você está inspecionando (eles ficam esmaecidas quando estão fora do escopo).
Examinar a pilha de chamadas

1. Durante a pausa no loop for , clique na janela Pilha de Chamadas que fica aberta por padrão no painel
inferior direito.
Se ele estiver fechado, abra-o enquanto estiver em pausa no depurador escolhendo depurar > Windows >
pilha de chamadas do Windows.
2. Clique em F11 algumas vezes até ver a pausa do depurador no SendMessage método. Examine a janela
Pilha de Chamadas .
A janela Pilha de Chamadas mostra a ordem em que os métodos e as funções são chamados. A linha
superior mostra a função atual (o método SendMessage neste aplicativo). A segunda linha mostra que
SendMessage foi chamado por meio do método Main e assim por diante.
NOTE
A janela Pilha de Chamadas é semelhante à perspectiva de Depuração em alguns IDEs, como o Eclipse.
A pilha de chamadas é uma boa maneira de examinar e entender o fluxo de execução de um aplicativo.
Você pode clicar duas vezes em uma linha de código para examinar esse código-fonte. Isso também altera o
escopo atual que está sendo inspecionado pelo depurador. Essa ação não avança o depurador.
Você também pode usar os menus acessados ao clicar com o botão direito do mouse na janela Pilha de
Chamadas para fazer outras coisas. Por exemplo, você pode inserir pontos de interrupção em funções
especificadas, avançar o depurador usando Executar até o Cursor e examinar o código-fonte. Para obter
mais informações, confira Como examinar a pilha de chamadas.
Alterar o fluxo de execução

1. Pressione F11 duas vezes para executar Console.WriteLine o método.
2. Com o depurador pausado na chamada SendMessage do método, use o mouse para pegar a seta amarela (o
ponteiro de execução) à esquerda e mova a seta amarela uma linha para cima, voltando Console.WriteLine
para.
3. Pressione F11 .
O depurador executa novamente o método Console.WriteLine (você vê isso na saída da janela do console).
Alterando o fluxo de execução, você pode fazer coisas como testar caminhos de execução de código
diferentes ou executar novamente o código sem reiniciar o depurador.
WARNING
Geralmente, você precisa ter cuidado com esse recurso. Um aviso é exibido na dica de ferramenta. Outros avisos
também podem ser exibidos. Ao mover o ponteiro não é possível reverter o aplicativo para um estado anterior.
4. Pressione F5 para continuar a execução do aplicativo.

Parabéns por concluir este tutorial.
Próximas etapas
Neste tutorial, você aprendeu como iniciar o depurador, percorrer o código e inspecionar variáveis. Talvez você
queira obter uma visão geral dos recursos do depurador, com links para mais informações.
Introdução ao depurador
Introdução ao teste de unidade
Use o Visual Studio para definir e executar testes de unidade para manter a integridade de código, assegurar a
cobertura de código e localizar erros e falhas antes de seus clientes. Execute os testes de unidade frequentemente
para ter certeza de que seu código está funcionando corretamente.
Criar testes de unidade

Esta seção descreve como criar um projeto de teste de unidade.
1. Abra o projeto que você deseja testar no Visual Studio.
Para fins de demonstração de um exemplo de teste de unidade, este artigo testa um projeto simples de "Olá,
Mundo" chamado HelloWorldCore . O código do exemplo para um projeto desse tipo é o seguinte:
namespace HelloWorldCore
public class Program

{
public static void Main()
{
Console.WriteLine("Hello World!");
}
}
2. No Gerenciador de Soluções , selecione o nó da solução. Em seguida, na barra de menus superior,

selecione arquivo > Adicionar > novo projeto .
3. Na caixa de diálogo Novo Projeto, localize um modelo de projeto de teste de unidade para a estrutura de
teste que você deseja usar e selecione-o.
Clique em Avançar , escolha um nome para o projeto de teste e, em seguida, clique em Criar .
Escolha um nome para o projeto de teste e clique em OK .

O projeto é adicionado à solução.
4. No projeto de teste de unidade, adicione uma referência ao projeto que você deseja testar clicando com o
botão direito do mouse em Referências ou Dependências e, em seguida, escolhendo Adicionar
Referência .
5. Selecione o projeto que contém o código que você testará e clique em OK .
6. Adicione código ao método de teste de unidade.

Por exemplo, para um projeto MSTest, você pode usar o código a seguir.
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.IO;
using System;
namespace HelloWorldTests
{
[TestClass]
public class UnitTest1
{
private const string Expected = "Hello World!";
[TestMethod]
public void TestMethod1()
{
using (var sw = new StringWriter())
{
Console.SetOut(sw);
HelloWorldCore.Program.Main();
var result = sw.ToString().Trim();

Assert.AreEqual(Expected, result);
}
}
}
}
Ou, para um projeto NUnit, você pode usar o código a seguir.

using NUnit.Framework;
using System.IO;
using System;
namespace HelloWorldTests
{
public class Tests
{
private const string Expected = "Hello World!";
[SetUp]
public void Setup()
{
}
[Test]
public void TestMethod1()
{
using (var sw = new StringWriter())
{
Console.SetOut(sw);
HelloWorldCore.Program.Main();
var result = sw.ToString().Trim();

Assert.AreEqual(Expected, result);
}
}
}
}
TIP
Para obter mais detalhes sobre como criar testes de unidade, consulte criar e executar testes de unidade para código
gerenciado.
Executar testes de unidade

1. Abra o Gerenciador de testes.
Para abrir o Gerenciador de testes, escolha testar > Gerenciador de testes na barra de menus superior.
Para abrir o Gerenciador de testes, escolha testar > o Gerenciador de testes do Windows > na barra de
menus superior.
2. Execute seus testes de unidade clicando em Executar Tudo .
Depois de concluir os testes, uma marca de seleção verde indica que houve aprovação em um teste. Um
ícone "x" vermelho indica falha em um teste.
TIP
Você pode usar o Gerenciador de Testes para executar testes de unidade do framework de testes interno (MSTest) ou de
estruturas de teste de terceiros. Você pode agrupar os testes em categorias, filtrar a lista de testes, criar, salvar e executar
playlists de testes. Você também pode depurar testes e analisar um teste de desempenho e cobertura de código.
Exibir resultados de teste de unidade em tempo real

Se estiver usando a estrutura de teste do MSTest, do xUnit ou do NUnit no Visual Studio de 2017 ou posterior, você
poderá ver os resultados em tempo real de seus testes de unidade.
NOTE
O Live Unit Testing está disponível somente no Enterprise Edition.
1. Ative o Live Unit Testing do menu Teste , escolhendo Teste > Live Unit Testing > Iniciar .
2. Exiba os resultados dos testes dentro da janela do editor de código conforme você escreve e edita o código.
3. Clique em um indicador de resultado do teste para obter mais informações, assim como os nomes dos
testes que abordam esse método.
Para obter mais informações sobre o Live Unit Testing, veja Live Unit Testing.
Gerar testes de unidade com IntelliTest

Quando executa o IntelliTest, você pode ver quais testes estão falhando e adicionar o código que for necessário
para corrigi-los. É possível selecionar quais dos testes gerados serão salvos em um projeto de teste para oferecer
um pacote de regressão. Conforme você alterar seu código, execute novamente o IntelliTest para manter os testes
gerados em sincronia com as alterações do código. Para saber como, confira Gerar testes de unidade para seu
código com o IntelliTest.
TIP
O IntelliTest está disponível somente para código gerenciado direcionado ao .NET Framework.
Analisar a cobertura de código

Para determinar que proporção do código do projeto está sendo testada de fato por testes codificados, como os
testes de unidade, você pode usar o recurso de cobertura de código do Visual Studio. Para se proteger efetivamente
contra bugs, os testes devem usar uma grande proporção do seu código. Para saber como, consulte usar a
cobertura de código para determinar a quantidade de código que está sendo testada.
Usar uma estrutura de teste de terceiros

Você pode executar testes de unidade no Visual Studio usando estruturas de teste de terceiros, como Boost, Google
e NUnit. Use o Gerenciador de Pacotes NuGet para instalar o pacote do NuGet para a estrutura de sua escolha.
Ou, para estruturas de teste NUnit e xUnit, o Visual Studio inclui modelos de projeto de teste pré-configurados que
incluem os pacotes NuGet necessários.
Para criar testes de unidade que usam NUnit:
1. Abra a solução que contém o código que você deseja testar.
2. Clique com o botão direito do mouse na solução no Gerenciador de Soluções e escolha Adicionar >
Novo Projeto .
3. Selecione o modelo de projeto Projeto de Teste do NUnit .
Clique em Avançar , nomeie o projeto e clique em Criar .
Nomeie o projeto e clique em OK para criá-lo.
O modelo de projeto inclui referências de NuGet a NUnit e NUnit3TestAdapter.
4. Adicione uma referência do projeto de teste ao projeto que contém o código que você deseja testar.
Clique com o botão direito do mouse no projeto no Gerenciador de Soluções e selecione Adicionar >
Referência . (Também é possível adicionar uma referência no menu do botão direito do nó Referências ou
Dependências .)
5. Adicione código ao método de teste.
6. Execute o teste do Gerenciador de Testes ou clicando com o botão direito do mouse no código de teste e
escolhendo Executar Testes .
Veja também
Passo a passo: Criar e executar testes de unidade para código gerenciado
Criar comando de testes de unidade
Gerar testes com o IntelliTest
Executar testes com o Gerenciador de Testes
Analisar a cobertura de código
Criar um banco de dados e adicionar tabelas no
Visual Studio
Você pode usar o Visual Studio para criar e atualizar um arquivo de banco de dados local no SQL Server Express
LocalDB. Você também pode criar um banco de dados executando instruções Transact-SQL na janela de
ferramentas do pesquisador de objetos do SQL Ser ver no Visual Studio. Neste tópico, vamos criar um arquivo
. MDF e adicionar tabelas e chaves usando o designer de tabela.
{1>{2>Pré-requisitos<2}<1}
Para concluir este passo a passos, você precisará do desenvolvimento de área de trabalho do .net e de
armazenamento de dados e cargas de trabalho de processamento instalados no Visual Studio. Para instalá-los,
abra instalador do Visual Studio e escolha Modificar (ou mais > Modificar ) ao lado da versão do Visual
Studio que você deseja modificar.
Criar um projeto e um arquivo de banco de dados local

1. Crie um novo projeto de aplicativo Windows Forms e nomeie-o SampleDatabaseWalkthrough .
2. Na barra de menus, selecione projeto > Adicionar novo item .
3. Na lista de modelos de item, role para baixo e selecione banco de dados baseado em ser viço .
4. Nomeie o banco de dados SampleDatabase e clique em Adicionar .

Adicionar uma fonte de dados
1. Se a janela fontes de dados não estiver aberta, abra-a pressionando Shift +ALT +D ou selecionando
Exibir > outras fontes de dados do Windows > na barra de menus.
2. Na janela fontes de dados , selecione Adicionar nova fonte de dados .
O Assistente de Configuração de Fonte de Dados é aberto.
3. Na página escolher um tipo de fonte de dados , escolha Database e, em seguida, escolha Avançar .
4. Na página escolher um modelo de banco de dados , escolha Avançar para aceitar o padrão (DataSet).
5. Na página escolher sua conexão de dados , selecione o arquivo SampleDatabase. MDF na lista
suspensa e escolha Avançar .
6. Na página salvar a cadeia de conexão no arquivo de configuração do aplicativo , escolha Avançar .
7. Na página escolher seus objetos de banco de dados , você verá uma mensagem dizendo que o banco
de dados não contém nenhum objeto. Escolha Concluir .
Exibir as propriedades da conexão de dados
Você pode exibir a cadeia de conexão para o arquivo SampleDatabase. MDF abrindo o janela Propriedades da
conexão de dados:
Selecione exibir > pesquisador de objetos do SQL Ser ver para abrir a janela pesquisador de
objetos do SQL Ser ver . Expanda (LocalDB) \MSSQLLocalDB > bancos de dados e clique com o
botão direito do mouse em SampleDatabase. MDF e selecione Propriedades .
Como alternativa, você pode selecionar exibir > Gerenciador de ser vidores , se essa janela ainda não
estiver aberta. Abra o janela Propriedades expandindo o nó conexões de dados , clicando com o botão
direito do mouse em SampleDatabase. MDFe, em seguida, selecionando Propriedades .
TIP
Se você não puder expandir o nó conexões de dados, ou se a conexão SampleDatabase. MDF não estiver listada,
selecione o botão conectar ao Database na barra de ferramentas Gerenciador de servidores. Na caixa de diálogo
Adicionar conexão , certifique-se de que Microsoft SQL Ser ver arquivo de banco de dados esteja selecionado
em fonte de dados e, em seguida, navegue até e selecione o arquivo SampleDatabase. MDF. Conclua a adição da
conexão selecionando OK .
Criar tabelas e chaves usando Designer de Tabela

Nesta seção, você criará duas tabelas, uma chave primária em cada tabela e algumas linhas de dados de exemplo.
Você também criará uma chave estrangeira para especificar como os registros em uma tabela correspondem aos
registros na outra tabela.
Criar a tabela Customers
1. Em Gerenciador de ser vidores , expanda o nó conexões de dados e expanda o nó SampleDatabase.
MDF .
Se você não puder expandir o nó conexões de dados, ou se a conexão SampleDatabase. MDF não estiver
listada, selecione o botão conectar ao Database na barra de ferramentas Gerenciador de servidores. Na
caixa de diálogo Adicionar conexão , certifique-se de que Microsoft SQL Ser ver arquivo de banco de
dados esteja selecionado em fonte de dados e, em seguida, navegue até e selecione o arquivo
SampleDatabase. MDF. Conclua a adição da conexão selecionando OK .
2. Clique com o botão direito do mouse em tabelas e selecione Adicionar nova tabela .
O Designer de Tabela é aberto e mostra uma grade com uma linha padrão, que representa uma única coluna
na tabela que você está criando. Adicionando linhas à grade, você adicionará colunas na tabela.
3. Na grade, adicione uma linha para cada uma das seguintes entradas:
N O M E DA C O L UN A T IP O DE DA DO S P ERM IT IR N ULO S
CustomerID nchar(5) Falso (desmarcado)
CompanyName nvarchar(50) Falso (desmarcado)
ContactName nvarchar (50) Verdadeiro (marcado)
Phone nvarchar (24) Verdadeiro (marcado)
4. Clique com o botão direito do mouse na linha CustomerID e selecione definir chave primária .
5. Clique com o botão direito do mouse na linha padrão ( Id ) e selecione excluir .
6. Nomeie a tabela Clientes atualizando a primeira linha no painel de script de acordo com o seguinte exemplo:
CREATE TABLE [dbo].[Customers]
Você deve ver algo parecido com isso:
7. No canto superior esquerdo da Designer de tabela , selecione Atualizar .

8. Na caixa de diálogo Visualizar atualizações do banco de dados , selecione Atualizar banco de dados .
A tabela Customers é criada no arquivo de banco de dados local.
Criar a tabela de pedidos
1. Adicione outra tabela e uma linha para cada entrada na seguinte tabela:
OrderID int Falso (desmarcado)
CustomerID nchar(5) Falso (desmarcado)

OrderDate datetime Verdadeiro (marcado)
OrderQuantity int Verdadeiro (marcado)
2. Defina OrderID como a chave primária e, em seguida, exclua a linha padrão.

3. Nomeie a tabela Orders atualizando a primeira linha no painel de script de acordo com o seguinte exemplo:
CREATE TABLE [dbo].[Orders]

A tabela Orders é criada no arquivo de banco de dados local. Se você expandir o nó tabelas no Gerenciador
de servidores, verá as duas tabelas:
Criar uma chave estrangeira

1. No painel de contexto no lado direito da grade de Designer de Tabela da tabela Orders, clique com o botão
direito do mouse em chaves estrangeiras e selecione Adicionar nova chave estrangeira .
2. Na caixa de texto exibida, substitua o texto pela tabela por clientes .

3. No painel T-SQL, atualize a última linha para corresponder ao exemplo a seguir:
CONSTRAINT [FK_Orders_Customers] FOREIGN KEY ([CustomerID]) REFERENCES [Customers]([CustomerID])

A chave estrangeira é criada.
Preencher as tabelas com dados

1. Em Gerenciador de ser vidores ou pesquisador de objetos do SQL Ser ver , expanda o nó do banco
de dados de exemplo.
2. Abra o menu de atalho para o nó tabelas , selecione Atualizar e, em seguida, expanda o nó tabelas .
3. Abra o menu de atalho da tabela clientes e selecione Mostrar dados da tabela .
4. Adicione quaisquer dados desejados para alguns clientes.
É possível especificar cinco caracteres desejados como IDs de cliente, mas escolha pelo menos um do qual é
possível se lembrar para uso posteriormente neste procedimento.
5. Abra o menu de atalho da tabela pedidos e selecione Mostrar dados da tabela .
6. Adicione dados para alguns pedidos.
IMPORTANT
Verifique se todas as IDs e as quantidades de pedido são inteiros e se cada ID do cliente corresponde a um valor
especificado na coluna CustomerID da tabela Clientes.
7. Na barra de menus, selecione arquivo > salvar tudo .
Veja também
Acessando dados no Visual Studio

Tutorial C# PDF

Enviado por

Direitos autorais:

Formatos disponíveis

Tutorial C# PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Tutorial C# PDF

Enviado por

Direitos autorais:

Formatos disponíveis

Contents

Recursos de produtividade populares

Para obter mais informações, consulte Início Rápido.

5. Para fechar a janela do console, pressione qualquer tecla do teclado.

Console.WriteLine("\nWhat is your name?");

6. Para fechar a janela do console, pressione qualquer tecla do teclado.

Console.WriteLine("\nWhat is your name?");

Usar a refatoração e o IntelliSense

int dayOfYear = now.DayOfYear;

Console.Write("Day of year: ");

Personalizar o Visual Studio

Selecionar configurações do ambiente

Criar um novo arquivo de código

2. Pressione a Guia duas vezes para inserir o snippet de código.

1. Cole o código a seguir no corpo do método Main() .

// _words is a string array that we'll sort alphabetically

IEnumerable<string> query = from word in _words

Recolher blocos de código

Exibir definições de símbolo

Usar o IntelliSense para completar palavras

foreach (string str in qu

Você verá o IntelliSense mostrar as Informações Rápidas sobre o símbolo query .

2. Para inserir o restante da palavra query usando a funcionalidade de preenchimento de palavras do

foreach (string str in query)

4. Nomeie a solução como QuickSolution e escolha Criar .

1. Ao clicar com o botão direito do mouse ou no menu de contexto da Solução ‘QuickSolution’ no

Adicionar um item ao projeto

internal static DateTime GetCurrentDate()

Adicionar um segundo projeto

Adicionar uma referência ao projeto

Adicionar código de teste

O arquivo de código deve ter esta aparência:

Criar aplicativos habilitados para a nuvem para o Azure

Criar aplicativos para a Web

Criar jogos e aplicativos de plataforma cruzada

Conectar-se aos bancos de dados

Depurar, testar e melhorar o código

Implantar o aplicativo concluído

Gerenciar seu código-fonte e colaborar com outros

Estenda o Visual Studio

Adicionar uma carga de trabalho (opcional)

2. O Instalador do Visual Studio é iniciado. Escolha a carga de trabalho Desenvolvimento multiplaforma do

Opção 2: usar a barra de menus Ferramentas

Em seguida, no Instalador do Visual Studio, escolha a carga de trabalho de desenvolvimento multiplataforma do

Especificamente, exclua a linha com o texto: Console.WriteLine("Hello World!"); .

Uma janela do console é aberta mostrando a soma de 42 + 119, que é 161 .

// Display title as the C# console calculator app.

// Ask the user to type the first number.

// Ask the user to type the second number.

// Ask the user to choose an option.

// Use a switch statement to do the math.

3. Escolha Calculadora para executar seu programa ou pressione F5 .

Uma janela do console é aberta.

Vamos corrigir o código para que ele identifique decimais.

3. Execute novamente o aplicativo de calculadora e divida o número 42 pelo número 119 .

(Corrigiremos o número de casas decimais na seção Revisar o código.)

Corrigir o erro de "divisão por zero"

Vamos alterar o código para tratar esse erro.

// Ask the user to enter a non-zero divisor until they do so.