Visualstudio Get Started Csharp Vs 2019

Dê a sua opinião sobre a experiência de download do PDF.
Tutoriais do Visual Studio | C#

Crie aplicativos em C# com o Visual Studio.
Introdução
ｃ GUIA DE INSTRUÇÕES
Baixar e instalar o Visual Studio
ｂ COMEÇAR AGORA
Iniciar um tour guiado
ｆ INÍCIO RÁPIDO
Criar um aplicativo Web "Olá, Mundo"
Criar aplicativos em C#
ｇ TUTORIAL
Criar um aplicativo de console
Criar um aplicativo Web
Criar um aplicativo SDK do aplicativo do Windows
Criar um aplicativo da área de trabalho do Windows
Criar um aplicativo do Windows Forms
Saiba mais sobre a linguagem C#
Jogo de correspondência do Windows Forms
Teste de matemática do Windows Forms
Visualizador de imagens do Windows Forms
Aprender a usar o Visual Studio
ｇ TUTORIAL
Executar um programa
Abrir código de um repositório
Escrever e editar o código
Compilar e criar
Depurar seu código
Testar seu código
Acessar dados
Bem-vindo ao IDE do Visual Studio | C#
Artigo • 18/03/2023
Aplica-se a: Visual Studio Visual Studio para Mac Visual Studio Code
Um ambiente de desenvolvimento integrado (IDE) é um programa repleto de recursos

que suporta muitos aspectos do desenvolvimento de software. O IDE do Visual Studio é
uma plataforma de lançamento criativa que você pode usar para editar, depurar e
compilar código e, em seguida, publicar um aplicativo. Além do editor e depurador
padrão fornecidos pela maioria dos IDEs, o Visual Studio inclui compiladores,
ferramentas de conclusão de código, designers gráficos e muitos outros recursos para
aprimorar o processo de desenvolvimento de software.
A imagem anterior mostra o Visual Studio com um projeto aberto que exibe as janelas
principais e suas funcionalidades:
No Gerenciador de Soluções, no canto superior direito, você pode exibir, navegar e

gerenciar seus arquivos de código. O Gerenciador de Soluções pode ajudar a
organizar o código agrupando os arquivos em soluções e projetos.
A janela do editor central, na qual você provavelmente passará a maior parte do

tempo, exibe os conteúdos do arquivo. Nessa janela, você pode editar o código ou
criar uma interface do usuário, como uma janela com botões e caixas de texto.
Em Alterações do Git, no canto inferior direito, você pode acompanhar itens de

trabalho e compartilhar código com outras pessoas usando tecnologias de
controle de versão, como o Git e o GitHub .
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 para Windows e é otimizado para
o desenvolvimento de aplicativos móveis e multiplataforma. Esse artigo concentra-se na
versão Windows do Visual Studio.
Há três edições do Visual Studio: Community, Professional e Enterprise. Consulte

Comparar as edições do Visual Studio para saber quais recursos são compatíveis com
cada edição.
Recursos de produtividade populares

Alguns recursos populares no Visual Studio que melhoram sua produtividade ao
desenvolver 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 ajudam a corrigir
problemas imediatamente, sem esperar para descobrir erros durante a compilação
ou o runtime. Se você passar o mouse sobre um rabisco, verá mais informações
sobre o erro. Uma lâmpada também pode aparecer na margem esquerda
mostrando Ações Rápidas que você pode executar para corrigir o erro.
Limpeza de código
Com o clique de um botão, você pode formatar seu código e aplicar 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, disponível
atualmente apenas para o código C#, ajuda você a resolver problemas em seu
código antes da transferência para revisão de código.
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 e alteração da ordem dos
parâmetros de método.
IntelliSense
IntelliSense é um conjunto de recursos que exibe informações sobre seu código

diretamente no editor e, em alguns casos, grava pequenos trechos de código para
você. É como ter a documentação básica embutida no editor, assim, você não
precisa consultar informações de tipo em outro lugar.
A seguinte ilustração mostra como o IntelliSense exibe uma lista de membros para
um tipo:
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.
Pesquisa do Visual Studio
Os menus, as opções e as propriedades do Visual Studio podem parecer

assustadores às vezes. A pesquisa do Visual Studio, ou Ctrl+Q, é uma ótima
maneira de localizar rapidamente os recursos e o código do IDE em um só lugar.
Para obter informações e dicas de produtividade, consulte Como usar a pesquisa
do Visual Studio.
Live Share
Edite e depure de maneira colaborativa com outras pessoas em tempo real,

independentemente do seu tipo de aplicativo ou linguagem de programação.
Você pode compartilhar seu projeto instantaneamente e com segurança. Você
também pode compartilhar sessões de depuração, instâncias de terminal,
aplicativos Web 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 informações podem ser ú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 de código, alterações de código,

bugs vinculados, itens de trabalho, revisões de código e testes de unidade sem sair
do editor.
Ir para definição
A funcionalidade Ir para Definição leva você diretamente para a localização de

uma função ou definição de tipo.
Inspecionar Definição
A janela Espiar Definição mostra uma definição de método ou tipo sem abrir um
arquivo separado.
Instalar o Visual Studio

Nessa seção, você cria um projeto simples para experimentar algumas coisas que pode
fazer com o Visual Studio. Você usa o IntelliSense como auxílio de codificação, depura
um aplicativo para ver o valor de uma variável durante a execução do aplicativo e altera
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 as linguagens de programação ou plataformas de que você deseja. Para seguir as
etapas para criar um programa, selecione a carga de trabalho Desenvolvimento
multiplataforma do .NET Core durante a instalação.
Ao abrir o Visual Studio pela primeira vez, você pode entrar usando sua conta da
Microsoft ou sua conta corporativa ou de estudante.
Criar um programa
Experimente e crie um programa simples.
1. Abra o Visual Studio.
A janela de início é exibida com opções para clonar um repositório, abrir um

projeto recente ou criar um novo projeto.
2. Escolha Criar um novo projeto.

A janela Criar um novo projeto é aberta e mostra diversos modelos de projeto. Um
modelo inclui as configurações e os arquivos básicos necessários para um tipo de
projeto específico.
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 Todas as linguagens, Windows na lista
Todas as plataformas e Console na lista Todos os tipos de projeto.
Selecione o modelo Aplicativo de Console e depois clique em Avançar.
4. Na janela Configurar seu novo projeto, insira OláMundo na caixa Nome do

projeto. Como opção, altere a localização do diretório dos seus arquivos de
projeto (o local padrão é C:\Users\<name>\source\repos ) e clique em Avançar.
5. Na janela Informações adicionais, verifique se o .NET Core 3.1 aparece no menu
suspenso Estrutura de Destino e clique em Criar.
O Visual Studio cria o projeto. É um aplicativo simples "Olá, Mundo" que chama o
método Console.WriteLine() para exibir a cadeia de caracteres literal "Olá, Mundo!"
na janela de console (saída do programa).
Em breve, você deverá ver algo parecido com a tela a seguir:

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.
6. 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.
7. Para fechar a janela do console, pressione qualquer tecla do teclado.
8. Vamos acrescentar mais alguns códigos ao aplicativo. Adicione o código C# a

seguir antes da linha que diz Console.WriteLine("Hello World!"); :
C#
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.
9. Altere a linha que indica Console.WriteLine("Hello World!"); para o seguinte

código:
C#
Console.WriteLine($"\nHello {name}!");
10. 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.
11. Insira seu nome na janela do console e pressione Enter.
12. 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, renomeie a variável name :
1. Clique duas vezes na variável name e digite o novo nome da variável, username.
Uma caixa aparece ao redor da variável e uma lâmpada é exibida na margem.
2. 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. Agora dê 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. A descrição do membro

atualmente selecionado também é exibida em uma caixa separada.
4. Selecione o membro chamado Agora, que é uma propriedade da classe, clicando

duas vezes nele ou pressionando Tab. Conclua a linha de código adicionando um
ponto e vírgula ao final da linha: DateTime now = DateTime.Now; .
5. Abaixo dessa linha, insira as linhas de código a seguir:
C#
int dayOfYear = now.DayOfYear;
Console.Write("Day of year: ");

Console.WriteLine(dayOfYear);
 Dica
Console.Write é 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 as descrições.
6. Em seguida, use novamente a refatoração para tornar o código um pouco mais
conciso. Selecione a variável now na linha DateTime now = DateTime.Now; . Um ícone
de chave de fenda é exibido na margem dessa linha.
7. Selecione o ícone de chave de fenda para ver as sugestões disponíveis no Visual

Studio. Esse caso mostra a refatoração Variável temporária embutida para remover
uma linha de código sem alterar o comportamento geral do código.
8. Selecione Variável temporária embutida para refatorar o código.
9. Execute o programa novamente pressionando Ctrl+F5. A saída é parecida com

esta:
Depurar o código
Ao escrever o código, você deve 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. Você pode
definir pontos de interrupção que interrompem a execução do código em uma linha
específica e observar como o valor da variável é alterado conforme o código é
executado.
Defina um ponto de interrupção para ver o valor da variável username enquanto o

programa é executado.
1. Defina um ponto de interrupção na linha de código que diz
Console.WriteLine($"\nHello {username}!"); clicando na margem extrema
esquerda, ou medianiz, ao lado da linha. Você também pode selecionar a linha de
código e, em seguida, pressionar F9.
Um círculo vermelho aparece na medianiz e a linha é destacada.
2. Inicie a depuração selecionando Depurar>Iniciar Depuração ou pressionando F5.
3. Quando a janela do console for exibida e solicitar seu nome, insira-o.
O foco retorna para o editor de códigos do Visual Studio e a linha de código com
o ponto de interrupção é destacada em amarelo. O destaque amarelo significa que
essa linha de código será executada em seguida. O ponto de interrupção faz com
que o aplicativo pause a execução nesta linha.
4. Passe o mouse sobre a variável username para ver seu valor. Você também pode
clicar com o botão direito do mouse em username e selecionar Adicionar Inspeção
para adicionar a variável à janela Inspeção, na qual você também pode ver o valor.
5. Pressione F5 novamente para concluir a execução do aplicativo.
Para obter mais informações sobre depuração no Visual Studio, consulte Tour pelo
recurso 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 o tema de cores:
1. Na barra de menus, escolha Ferramentas>Opções 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.
Para conhecer outras maneiras pelas quais você pode personalizar o IDE, confira
Personalizar o Visual Studio.
Selecionar configurações do ambiente

Você pode configurar o Visual Studio para usar configurações de ambiente
personalizadas para os desenvolvedores em C#:
1. Na barra de menus, escolha Ferramentas>Importar e Exportar Configurações.
2. No Assistente de Importação e Exportação de Configurações, selecione Redefinir

todas as configurações e, em seguida, selecione Avançar.
3. Na página Salvar Configurações Atuais, escolha se deseja salvar as configurações

atuais antes de redefinir. Se você ainda não personalizou as configurações,
selecione Não, apenas redefina as configurações, substituindo minhas
configurações atuais. Em seguida, selecione Avançar.
4. Na página Escolher uma Coleção Padrão de Configurações, escolha Visual C# e,

em seguida, selecione Concluir.
5. Na página Redefinição Concluída, selecione 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 o blog do Visual Studio .
com C#
Artigo • 19/06/2023
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 C#.
Se você ainda não tiver instalado o Visual Studio, acesse a página Downloads do Visual
Studio para instalá-lo gratuitamente.
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.
 Dica
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 menus, escolha Novo>Arquivo 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 chave de fechamento final } no arquivo e digite os

caracteres svm (que significam static void Main 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.

Examine os snippets de código disponíveis para a linguagem escolhendo
Editar>IntelliSense>Inserir Snippet ou pressionando Ctrl+K, Ctrl+X e, em seguida,
escolhendo a pasta da linguagem. 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() .
C#
// _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 Assinalar como comentário as linhas
selecionadas na barra de ferramentas. Caso prefira 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

Como não desejamos ver o construtor vazio que foi gerado para Class1 , vamos
recolhê-lo para que o código não seja mais exibido. Escolha a pequena caixa cinza com
o sinal de subtração dentro da margem da primeira linha do construtor. Ou, se você
preferir usar o teclado, posicione 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 adição ou pressione Ctrl+M, Ctrl+M novamente. Esse
recurso é chamado de Estrutura de tópicos e é útil principalmente ao recolher 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 em que o símbolo for
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. Se preferir, 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 valioso quando você está gravando o código. 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:

C#
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 .
C#
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 a definição da variável _words e selecione Renomear ao

clicar com o botão direito do mouse ou no menu de contexto, ou ao pressionar
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
Introdução a projetos e soluções
Artigo • 05/12/2023
Este artigo introdutório analisa o que significa criar uma solução e um projeto no Visual
Studio. Uma solução é um contêiner para organizar um ou mais projetos de código
relacionados, por exemplo, um projeto de biblioteca de classes e um projeto de teste
correspondente.
Como um exercício educacional para compreendermos o conceito de um projeto,

desenvolveremos uma solução e um projeto do zero. Normalmente, você usaria
modelos de projeto do Visual Studio para criar novos projetos. Você também analisará as
propriedades de um projeto e alguns dos arquivos ali contidos e criará uma referência
de um projeto para outro.
７ Observação
O desenvolvimento de aplicativos no Visual Studio não requer soluções e projetos.

Basta também abrir uma pasta que contém o código e começar a codificar,
compilar e depurar. Por exemplo, se você clonar um repositório GitHub , ele pode
não conter projetos nem soluções do Visual Studio. Para obter mais informações,
consulte Desenvolver código no Visual Studio sem projetos nem soluções.
Se você ainda não tiver instalado o Visual Studio 2019, acesse a página Downloads do
Visual Studio para a instalação gratuita.
Soluções e projetos
No Visual Studio, uma solução não é uma "resposta". Uma solução é apenas um
contêiner do Visual Studio usado para organizar um ou mais projetos relacionados.
Quando você abre uma solução, o Visual Studio carrega automaticamente todos os
projetos contidos na solução.
Criar uma solução

Inicie nossa análise criando uma solução vazia. Depois de se familiarizar com o Visual
Studio, você provavelmente não vai criar soluções vazias com muita frequência. Quando
você cria um novo projeto, o Visual Studio cria automaticamente uma solução para o
projeto, a menos que uma solução já esteja aberta.
2. Na janela inicial, selecione 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 selecione Avançar.
 Dica
Se você tiver várias cargas de trabalho instaladas, o modelo Solução em

Branco poderá não aparecer na parte superior da lista de resultados da
pesquisa. Tente rolar para a seção Outros resultados com base na sua
pesquisa da lista. Deve ser exibido como:
4. Nomeie a solução como QuickSolution e selecione 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 adicione seu primeiro projeto à solução. Comece com um projeto vazio e
adicione os itens necessários.
1. Ao clicar com o botão direito do mouse ou no menu de atalho da Solução
´QuickSolution’ no Gerenciador de Soluções, selecione Adicionar>Novo Projeto.
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, selecione Criar.
Um projeto chamado QuickDate é exibido abaixo da solução no Gerenciador de

Soluções. Atualmente, ele contém um único arquivo chamado App.config.
７ Observação
Se você não visualizar o modelo Projeto Vazio (.NET Framework), instale a

carga de trabalho do Visual Studio de desenvolvimento para área de
trabalho do .NET. O Visual Studio usa a instalação baseada em carga de
trabalho para instalar somente os componentes necessários para o tipo de
desenvolvimento realizado.
Uma maneira fácil de instalar uma nova carga de trabalho ao criar um novo
projeto é selecionar o link Instalar mais ferramentas e recursos no texto
indicando Não encontrou o que estava procurando?. Depois que o Instalador
do Visual Studio for iniciado, selecione a carga de trabalho Desenvolvimento
para desktop do .NET e, em seguida, o botão Modificar.
Adicionar um item ao projeto
Adicione um arquivo de código ao seu projeto vazio.
1. No menu de atalho ou com o botão direito do mouse no projeto QuickDate no

Gerenciador de Soluções, selecione Adicionar>Novo Item.
A caixa de diálogo Adicionar Novo Item é aberta. Selecione Mostrar todos os

modelos se a caixa de diálogo for aberta no modo de exibição compacto.
2. Expanda Itens do Visual C#e selecione Código. No painel central, selecione o

modelo de item Classe. Em Nome, digite Calendário e selecione Adicionar.
O Visual Studio adiciona um arquivo chamado Calendar.cs ao projeto. O .cs no final

é a extensão de arquivo fornecida aos arquivos de código C#. O arquivo
Calendar.cs aparece na hierarquia do projeto visual Gerenciador de Soluções e o
arquivo é aberto no editor.
3. Substitua o conteúdo do arquivo Calendar.cs pelo seguinte código:
C#
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;
}
}
}
Não é preciso entender tudo o que o código está fazendo. Execute o aplicativo
pressionando Ctrl+F5 e veja se o aplicativo imprime a data de hoje no console ou
na janela de saída padrão. Feche a janela do console.
Adicionar um segundo projeto

Geralmente, as soluções contêm mais de um projeto e esses projetos referenciem 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.
Para adicionar um projeto de teste de unidade à sua solução, comece com um modelo
de projeto para que você não precise adicionar outro arquivo de código ao projeto.
1. Ao clicar com o botão direito do mouse ou no menu de atalho da Solução

´QuickSolution’ no Gerenciador de Soluções, selecione Adicionar>Novo Projeto.
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. Selecione o modelo de projeto Projeto de Teste de Unidade para .NET Core e, em

seguida, selecione Avançar.
７ Observação
No Visual Studio 2019 versão 16.9 e posteriores, o nome do modelo de

projeto MSTest foi alterado de Projeto de Teste de Unidade do MSTest (.NET
Core) para Projeto de Teste de Unidade. Várias etapas na criação do projeto
foram alteradas nesta atualização.
4. Nomeie o projeto QuickTest e escolha Avançar.

5. Selecione a estrutura de destino recomendada (.NET Core 3.1) ou .NET 5 e
selecione 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 seu método no projeto
QuickDate. Portanto, precisamos adicionar uma referência a esse projeto QuickDate ao
QuickTest. A adição de referência cria uma dependência de build entre os dois projetos,
o que significa que quando a solução é criada, o QuickDate cria antes o QuickTest.
1. Selecione o nó Dependências no projeto QuickTest e, ao clicar com o botão

direito do mouse ou no menu de contexto, selecione Adicionar referência de
projeto.
A caixa de diálogo Gerenciador de Referências é aberta.
2. No painel esquerdo, expanda Projetos e selecione Solução. No painel central,

selecione a caixa de seleção ao lado de QuickDate e, em seguida, selecione OK.
Uma referência ao projeto QuickDate será adicionada.

Adicionar código de teste
1. Agora, adicione o código de teste ao arquivo de código de teste C#. Substitua o
conteúdo do UnitTest1.cs pelo seguinte código:
C#
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());
}
}
}
Uma linha sinuosa vermelha aparece em alguns dos códigos. É possível corrigir
esse erro ao tornar o projeto de teste um assembly amigável para o projeto
QuickDate.
2. No arquivo Calendar.cs, adicione a instrução using a seguir e o

InternalsVisibleToAttributeatributo à parte superior do arquivo, para resolver o erro
no projeto de teste.
C#
using System.Runtime.CompilerServices;
[assembly: InternalsVisibleTo("QuickTest")]
O código Calendar.cs deve ser semelhante a esta captura de tela:
Execute o teste de unidade

Para verificar se seu teste de unidade está funcionando, selecione Teste>Executar Todos
os Testes na barra de menu. A janela Gerenciador de Testes será aberta e você verá que
o teste TestGetCurrentDate será aprovado.
 Dica
Abra também o Gerenciador de Testes escolhendo Teste>Gerenciador de Testes

na barra de menu.
Propriedades do projeto
A linha no arquivo Calendar.cs que contém o atributo InternalsVisibleToAttribute
referencia o nome do assembly ou 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, use as propriedades do projeto. As páginas de
propriedades contêm várias configurações para o projeto.
1. Em Gerenciador de Soluções, clique com o botão direito do mouse no projeto

QuickTest e selecione Propriedades ou selecione o projeto e pressione Alt+Enter.
As páginas de propriedades do projeto são abertas na guia Aplicativo. O nome do

assembly do projeto QuickTest é, de fato, QuickTest.
Se desejar, é possível alterar o nome aqui. Quando você criar o projeto de teste, o
nome do arquivo binário resultante será alterado de QuickTest.dll para
<NewName>.dll.
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.
Confira também
Trabalhar com projetos e soluções
Desenvolver código no Visual Studio sem projetos nem soluções
Gerenciar propriedades do projeto e da solução
Gerenciar referências em um projeto
Funcionalidades do Visual Studio
Artigo • 03/09/2023
Este artigo descreve recursos para desenvolvedores experientes ou que já estão

familiarizados com o Visual Studio. Para uma introdução básica ao Visual Studio, confira
a visão geral do IDE do Visual Studio.
Instalação modular
No instalador modular do Visual Studio, você escolhe e instala as cargas de trabalho
desejadas. Cargas de trabalho são grupos de recursos que as linguagens de
programação ou plataformas precisam para funcionar. Essa estratégia modular ajuda a
manter o volume da instalação do Visual Studio menor e, assim, ele instala e atualiza
mais rapidamente.
Para saber mais sobre como configurar o Visual Studio no sistema, confira Instalar o
Visual Studio.
Criar aplicativos do Azure habilitados para

nuvem
O Visual Studio tem um conjunto de ferramentas para criar aplicativos habilitados para
nuvem do Microsoft Azure com facilidade. Você pode configurar, compilar, depurar,
empacotar e implantar aplicativos e serviços do Azure diretamente do IDE (ambiente de
desenvolvimento integrado) do Visual Studio. Para obter as ferramentas e modelos de
projeto do Azure, selecione a carga de trabalho Desenvolvimento do Azure ao instalar
o Visual Studio.
No Visual Studio, use o Cloud Explorer para ver e gerenciar seus recursos de nuvem
baseados no Azure. Os recursos de nuvem podem incluir VMs (máquinas virtuais),
tabelas e bancos de dados SQL. O Cloud Explorer mostra os recursos do Azure em
todas as contas da assinatura do Azure à qual você está conectado. Se uma operação
exigir o portal do Azure, o Cloud Explorer terá links para o local do portal que você
precisará acessar.
É possível usar os serviços do Azure para seus aplicativos adicionando Serviços

Conectados como:
Serviço conectado do Active Directory para usar contas do Azure AD (Azure Active
Directory ) para se conectar a 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 Serviç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>Serviç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 Web

O Visual Studio pode ajudar você a escrever aplicativos para a Web. Você pode criar
aplicativos Web usando ASP.NET, Node.js, Python, JavaScript e TypeScript. O Visual
Studio dá suporte a muitas estruturas da Web, como Angular, jQuery e Express.
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 o MVC, WebAPI e
SignalR. O ASP.NET Core foi projetado desde o princípio para fornecer uma pilha .NET
enxuta e combinável para criar 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

O Visual Studio pode criar aplicativos e jogos para macOS, Linux e Windows, bem como
para Android, iOS e outros dispositivos móveis . Com o Visual Studio, você pode criar:
Aplicativos .NET Core executados no Windows, macOS e Linux.

Aplicativos móveis para iOS, Android e Windows em C# e F# usando o Xamarin .
Jogos 2D e 3D em C# usando Ferramentas do Visual Studio para Unity.
Aplicativos C++ nativos para dispositivos iOS, Android e Windows. Compartilhe

código comum em bibliotecas do iOS, Android e Windows usando o C++ para
desenvolvimento multiplataforma.
Conectar-se aos bancos de dados

O Gerenciador de Servidores ajuda você a procurar e a gerenciar ativos e instâncias de
servidor locais, remotas e no Azure, no Microsoft 365, no Salesforce.com e em sites. Para
abrir o Gerenciador de Servidores, escolha Exibir>Gerenciador de Servidores. Para
obter mais informações de como usar o Gerenciador de Servidores, confira Adicionar
novas conexões.
O Pesquisador de Objetos do SQL Server fornece uma visão dos objetos de banco de
dados semelhante ao SQL Server Management Studio. Com o Pesquisador de Objetos
do SQL Server, você pode fazer o trabalho leve de administração e design de banco de
dados. Exemplos incluem editar dados de tabela, comparar esquemas e executar
consultas usando menus contextuais.
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. Com o
SSDT, você pode criar, depurar, dar manutenção 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. Para obter o SSDT, use o Instalador do
Visual Studio para instalar a carga de trabalho Armazenamento e processamento de
dados.
Depurar, testar e melhorar o código

Quando você escreve um código, é necessário executá-lo e testá-lo para verificar o
desempenho e se há bugs. Com o sistema de depuração do Visual Studio você pode
depurar o código em execução no projeto local, em um dispositivo remoto ou em um
emulador de dispositivo. Percorra o código uma instrução por vez e inspecione as
variáveis conforme avança. Ou defina pontos de interrupção que sejam alcançados
somente quando uma determinada condição for verdadeira. Você pode gerenciar as
opções de depuração no próprio editor de códigos para não ter que sair do código.
Para obter mais informações sobre depuração no Visual Studio, confira Primeiro contato
com o depurador.
Para melhorar o desempenho do aplicativo, confira o recurso de criação de perfil do

Visual Studio.
O Visual Studio oferece opções de testes como teste de unidade, Live Unit Testing,
IntelliTest e teste de desempenho e carga. O Visual Studio também aprimorou as
capacidades de análise de código para encontrar falhas de design, segurança e de
outros tipos.
Implantar o aplicativo concluído

O Visual Studio tem ferramentas para implantar seu aplicativo para usuários ou clientes
por meio da Microsoft Store, de um site do SharePoint ou das tecnologias InstallShield
ou Windows Installer. Você pode acessar todas essas opções por meio do IDE do Visual
Studio. Para obter mais informações, consulte Implantar aplicativos, serviços e
componentes.
Gerenciar seu código-fonte e colaborar com

outros
No Visual Studio você pode gerenciar o código-fonte em repositórios Git hospedados
por qualquer provedor, incluindo o GitHub. Você também pode procurar um Azure
DevOps Server para se conectar.
A forma como você abre um projeto de um repositório do GitHub usando o Visual

Studio 2019 depende da versão que você tem. Especificamente, se você instalou a
versão 16.8 ou posterior, há uma experiência do Git no Visual Studio nova e totalmente
integrada disponível para você. Para obter mais informações, consulte a página de
documentação de controle de versão do Visual Studio.
E, para ver um tutorial passo a passo sobre como se conectar a um repositório Git ou
Azure DevOps usando o Visual Studio, consulte a página Abrir um projeto de um
repositório.
Próximas etapas
Se o Visual Studio não tiver a funcionalidade exata de que você precisa, você pode
adicioná-la. Personalize o IDE de acordo com seu estilo e fluxo de trabalho,
adicione suporte para ferramentas externas que não estejam integradas ao Visual
Studio e modifique a funcionalidade existente para aumentar a sua produtividade.
Para saber qual é a versão mais recente das Ferramentas de Extensibilidade do
Visual Studio (SDK do VS), confira 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 por desenvolvedores

da Microsoft e pela comunidade de desenvolvimento do Visual Studio.
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
Tutorial: Criar um aplicativo de console
simples em C# no Visual Studio (parte 1
de 2)
Artigo • 17/11/2023
Neste tutorial, você usará o Visual Studio para criar e executar um aplicativo de console
do C# e explorar alguns recursos do IDE (ambiente de desenvolvimento integrado) do
Visual Studio. Este tutorial é a primeira parte de uma série com duas partes.
Neste tutorial, você completa as seguintes tarefas:
＂ Crie um projeto do Visual Studio.

＂ criar um aplicativo de console em C#.
＂ Depure o aplicativo.
＂ Feche seu aplicativo.
＂ Inspecione o código concluído.
Na parte 2, você estende esse aplicativo para adicionar mais projetos, aprender truques
de depuração e referenciar pacotes de terceiros.
Pré-requisitos
Você deve ter o Visual Studio instalado.
Criar um projeto
Para começar, crie um projeto de aplicativo em C#. O tipo de projeto vem com todos os
arquivos de modelo que você precisa.
1. Abra o Visual Studio e selecione Criar um novo projeto na janela Iniciar.

2. Na janela Criar um projeto, escolha C# na lista Linguagem. Em seguida, escolha
Windows na lista Plataforma e Console na lista de tipos de projeto.
Depois de aplicar os filtros de linguagem, plataforma e tipo de projeto, escolha o

modelo Aplicativo de Console e, em seguida, selecione Avançar.
７ Observação
Se você o modelo Aplicativo do Console não for exibido, selecione Instalar

mais ferramentas e recursos.
No Instalador do Visual Studio, selecione a carga de trabalho de

desenvolvimento multiplataforma do .NET Core.
Selecione o botão Modificar no Instalador do Visual Studio. Pode ser

necessário salvar o trabalho. Nesse caso, execute essa ação. Selecione
Continuar para instalar a carga de trabalho.
Retorne à etapa 2 neste procedimento "Criar um projeto".
3. Na janela Configurar seu novo projeto, digite ou insira Calculadora na caixa Nome
do projeto. Em seguida, selecione Avançar.
4. Na janela Informações adicionais, verifique se .NET Core 3.1 aparece no campo

Estrutura de Destino. Em seguida, selecione Criar.

O Visual Studio abre seu novo projeto, que inclui o código "Olá, Mundo" padrão. Para
exibi-lo no editor, selecione o arquivo de código Program.cs na janela Gerenciador de
Soluções, que normalmente está no lado direito do Visual Studio.
O código padrão "Olá, Mundo!" chama o método WriteLine para exibir a cadeia de
caracteres literal "Olá, Mundo!" na janela do console. Se pressionar F5, você poderá
executar o programa padrão no modo de depuração. Depois que o aplicativo é
executado no depurador, a janela do console permanece aberta. Pressione qualquer
tecla para fechar a janela do console.
Criar o aplicativo
Nesta seção, você concluirá as seguintes tarefas:
Explore os cálculos matemáticos básicos de inteiro em C#.

Adicione o código para criar um aplicativo de calculadora básica.
Depure o aplicativo para encontrar e corrigir erros.
Refine o código para torná-lo mais eficiente.
Explorar a matemática de inteiros

Comece 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, insira o seguinte código:
C#
int a = 42;
int b = 119;
int c = a + b;
Console.WriteLine(c);
Console.ReadKey();
Observe que quando você insere o código, o recurso IntelliSense no Visual Studio
oferece a opção de preenchimento automático da entrada.
3. Selecione o botão verde Iniciar ao lado da Calculadora para compilar e executar

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

Continue com a adição de um conjunto mais complexo de código de calculadora ao seu
projeto.
1. No editor de código, substitua todo o código em Program.cs pelo novo código:
C#
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();
}
}
}
2. Selecione o botão Calculadora ou pressione F5 para executar seu aplicativo.
Uma janela do console é aberta.
3. Na janela do console, siga os prompts para adicionar os números 42 e 119.
O aplicativo deverá ser semelhante à seguinte captura de tela:

Adicionar funcionalidade decimal
Agora, ajustaremos o código para adicionar mais funcionalidade.
O aplicativo de calculadora atual só aceita e retorna números inteiros. Por exemplo, se

você executar o aplicativo e dividir o número 42 pelo número 119, o resultado será zero,
o que não é exato.
Para corrigir o código para melhorar a precisão manipulando decimais:
1. Em Program.cs no editor do Visual Studio, pressione Ctrl+H para abrir o controle

Localizar e Substituir.
2. Digite int no controle e float no campo Substituir.
3. Selecione os ícones para Diferenciar maiúsculas e minúsculas e Coincidir palavra

inteira no controle ou pressione Alt+C e Alt+W.
4. Selecione o ícone Substituir tudo ou pressione Alt+A para executar a pesquisa e
substituir.
5. Execute novamente o aplicativo de calculadora e divida o número 42 pelo número

119.
O aplicativo agora retorna um numeral decimal em vez de zero.
Agora o aplicativo pode produzir resultados decimais. Fala mais alguns ajustes no
código, de modo que o aplicativo possa calcular decimais também.
6. Use o controle Localizar e Substituir para alterar cada instância da variável float
para double e alterar cada instância do método Convert.ToInt32 para
Convert.ToDouble .
7. Execute o aplicativo de calculadora e divida o número 42,5 pelo número 119,75.
O aplicativo agora aceita valores decimais e retorna um numeral decimal mais

longo como resultado.
Na seção Revisar o código, você reduz o número de casas decimais nos resultados.
Depurar o aplicativo
Você melhorou seu aplicativo de calculadora básica, mas seu aplicativo ainda não lida
com exceções, como erros de entrada do usuário. Por exemplo, se os usuários tentarem
dividir por zero ou inserir um caractere inesperado, o aplicativo poderá parar de
funcionar, retornar um erro ou retornar um resultado não numérico inesperado.
Vamos percorrer alguns erros comuns de entrada de usuário, localizá-los no depurador,

caso apareçam, e corrigi-los no código.
 Dica
Para obter mais informações sobre o depurador e como ele funciona, confira
Introdução ao depurador do Visual Studio.
Corrigir o erro de "divisão por zero"

Se você tentar dividir um número por zero, o aplicativo de console poderá congelar e
mostrará o que há de errado no editor de código.
７ Observação
À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 correção de código a seguir ainda se
aplica.
Vamos alterar o código para tratar esse erro. Em Program.cs, substitua o código de case
"d": pelo seguinte código:
C#
// 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ê substituir o código, a seção com a instrução switch deverá ser
semelhante à seguinte captura de tela:
Agora, quando você divide qualquer número por zero, o aplicativo solicita outro
número e continua perguntando até que você forneça um número diferente de zero.
Corrigir o erro de "formato"

Se você inserir um caractere alfabético quando o aplicativo esperar um caractere
numérico, o aplicativo congela. O Visual Studio mostra o que há de errado no editor de
códigos.
Para evitar essa exceção, você pode refatorar o código inserido anteriormente.
Revisar o código
Em vez de depender da classe program para tratar todo o código, você pode dividir seu
aplicativo em duas classes: Calculator e Program .
A classe Calculator faz a maior parte do trabalho de cálculo e a classe Program cuida
do trabalho de tratamento de erros e da interface do usuário.
Vamos começar.
1. Em Program.cs, exclua tudo e adicione a nova classe Calculator a seguir:
C#
class Calculator
{
public static double DoOperation(double num1, double num2, string
op)
{
double result = double.NaN; // Default value is "not-a-number"
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;
}
}
2. Além disso, adicione uma nova classe Program , da seguinte maneira:
C#
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:
");
{
integer value: ");
}
// 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;
}
}
3. Selecione o botão Calculadora ou pressione F5 para executar seu aplicativo.
4. Siga os prompts e divida o número 42 pelo número 119. O resultado deve ter
aparência semelhante à captura de tela a seguir:
Agora você pode executar mais cálculos até optar por fechar o aplicativo de
console. Também há menos casas decimais nos resultados. E se você inserir um
caractere incorreto, você receberá uma resposta de erro apropriada.
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 o aplicativo.
Adicionar o controle do código-fonte do Git

Agora que você criou um aplicativo, pode ser interessante adicioná-lo a um repositório
Git. O Visual Studio facilita esse processo com as ferramentas de Git que você pode usar
diretamente no IDE.
 Dica
O Git é o sistema de controle de versão moderno mais usado, portanto, se você é

um desenvolvedor profissional ou está aprendendo a codificar, o Git pode ser
muito útil. Se você é novo no Git, o site https://git-scm.com/ é um bom local
para começar. Lá você vai encontrar roteiros, um livro online popular e vídeos de
Conceitos Básicos do Git.
Para associar seu código ao Git, comece criando um repositório Git no local em que o
código está localizado:
1. Na barra de status no canto inferior direito do Visual Studio, selecione Adicionar

ao Controle do Código-Fonte e selecione Git.
2. Na caixa de diálogo Criar um repositório Git, entre no GitHub.

O nome do repositório é preenchido automaticamente com base no local da sua
pasta. O novo repositório é privado por padrão, o que significa que você é o único
que pode acessá-lo.
 Dica
Não importa se o repositório é público ou privado, é melhor ter um backup

remoto do código armazenado com segurança no GitHub. Mesmo que você
não esteja trabalhando com uma equipe, um repositório remoto disponibiliza
seu código para você em qualquer computador.
3. Selecione Criar e Efetuar Push.
Depois de criar o repositório, você verá detalhes do status na barra de status.
O primeiro ícone com as setas mostra quantos commits de saída/entrada estão no

branch atual. Você pode usar esse ícone para efetuar pull de qualquer commit de
entrada ou efetuar push de commits de saída. Você também pode optar por exibir
primeiro esses commits. Para fazer isso, selecione o ícone e selecione Exibir
Saída/Entrada.
O segundo ícone com o lápis mostra o número de alterações não confirmadas no

código. Você pode selecionar este ícone para exibir essas alterações na janela
Alterações do Git.
Para saber mais sobre como usar o Git com seu aplicativo, veja a documentação de
controle de versão do Visual Studio.
Revisão: conclusão do código

Neste tutorial, você fez muitas alterações no aplicativo 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:
C#
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":
break;
case "s":
break;
case "m":
break;
case "d":
if (num2 != 0)
{
}
break;
default:
break;
}
return result;
}
}
class Program
{
{
while (!endApp)
{
double result = 0;

{
integer value: ");
}

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

list:");
try
{
result = Calculator.DoOperation(cleanNum1, cleanNum2, op);
{
}
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: ");

}
return;
}
}
Próximas etapas
Prossiga para a segunda parte deste tutorial:
Parte 2 do Tutorial: Estender e depurar seu aplicativo de console em C#

Tutorial: estender o aplicativo de
console e a depuração do C# no Visual
Studio (parte 2 de 2)
Artigo • 31/10/2023
Na parte 2 desta série de tutoriais, você se aprofundará um pouco mais nos recursos de
build e depuração do Visual Studio necessários para o desenvolvimento diário. Esses
recursos incluem o gerenciamento de vários projetos, a depuração e a referência a
pacotes de terceiros. Você executará o aplicativo de console do C# criado na Parte 1
deste tutorial e explorará alguns recursos do IDE (ambiente de desenvolvimento
integrado) do Visual Studio. Este tutorial é a parte 2 de uma série com duas partes.
Neste tutorial, você completa as seguintes tarefas:
＂ Adicione um segundo projeto.

＂ Referencie bibliotecas e adicione pacotes.
＂ Depure seu código.
＂ Inspecione o código concluído.
Pré-requisitos
Para trabalhar com este artigo, você pode usar qualquer um destes aplicativos de
calculadora:
O aplicativo de console da calculadora da parte 1 deste tutorial.

O aplicativo de calculadora do C# no repositório vs-tutorial-samples . Para
começar, abra o aplicativo no repositório.
Adicionar outro projeto

O código do mundo real envolve projetos que trabalham em conjunto em uma solução.
Você pode adicionar um projeto de biblioteca de classes ao aplicativo de calculadora
que fornece algumas funções de calculadora.
No Visual Studio, você usa o comando de menu Arquivo>Adicionar>Novo Projeto para

adicionar um novo projeto. Você também pode clicar com o botão direito do mouse na
solução no Gerenciador de Soluções para adicionar um projeto no menu de contexto.
1. No Gerenciador de Soluções, clique com o botão direito do mouse no nó da
solução e escolha Adicionar>Novo projeto.
2. Na janela Adicionar um novo projeto, digite biblioteca de classes na caixa de

pesquisa. Escolha o modelo de projeto de biblioteca de classes do C# e, em
seguida, selecione Avançar.
3. Na tela Configurar seu novo projeto, digite o nome do projeto CalculatorLibrary e

selecione Avançar.
4. Escolha .NET 3.1, quando solicitado. O Visual Studio cria o novo projeto e adiciona
à solução.
5. Renomeie o arquivo Class1.cs como CalculatorLibrary.cs. Para renomear o arquivo,
você pode clicar com o botão direito do mouse no nome do mesmo no
Gerenciador de Soluções, escolher Renomear, selecionar o nome e pressionar F2,
ou selecionar o nome e selecionar novamente para digitar.
Uma mensagem pode perguntar se você deseja renomear as referências como

Class1 no arquivo. Não importa como você responde, pois o código será
substituído em uma próxima etapa.
6. Agora, adicione uma referência de projeto de modo que o primeiro projeto possa
usar as APIs expostas pela nova biblioteca de classes. Clique com o botão direito
do mouse no nó Dependências no projeto Calculadora e escolha Adicionar
Referência de Projeto.
A caixa de diálogo Gerenciador de Referências é exibida. Nesta caixa de diálogo,
você pode adicionar referências a outros projetos, assemblies e COM DLLs
necessários para os projetos.
7. Na caixa de diálogo Gerenciador de Referências, marque a caixa de seleção do

projeto CalculatorLibrary e selecione OK.
A referência de projeto será exibida no nó Projetos no Gerenciador de Soluções.

8. Em Program.cs, selecione a classe Calculator e todo o código e pressione Ctrl+X
para cortá-la. Em seguida, em CalculatorLibrary.cs, cole o código no namespace
CalculatorLibrary .
Adicione também public antes da classe Calculadora para expô-la fora da

biblioteca.
Agora o CalculatorLibrary.cs deve ser semelhante ao seguinte código:
C#
using System;
namespace CalculatorLibrary
{
public class Calculator
{
public static double DoOperation(double num1, double num2,
string op)
{
double result = double.NaN; // Default value is "not-a-
number" if an operation, such as division, could result in an error.

switch (op)
{
case "a":
break;
case "s":
break;
case "m":
break;
case "d":
if (num2 != 0)
{
}
break;
default:
break;
}
return result;
}
}
}
9. O Program.cs também tem uma referência, mas um erro diz que a chamada
Calculator.DoOperation não está sendo resolvida. Esse erro aparece porque
CalculatorLibrary está em um namespace diferente. Para uma referência
totalmente qualificada, você pode adicionar o namespace CalculatorLibrary à

chamada Calculator.DoOperation :
C#
result = CalculatorLibrary.Calculator.DoOperation(cleanNum1, cleanNum2,

op);
Ou você pode tentar adicionar uma diretiva using ao início do arquivo:
C#
using CalculatorLibrary;
Adicionar a diretiva using deve permitir que você remova o namespace

CalculatorLibrary do site de chamada, mas agora existe uma ambiguidade. A
classe Calculator está em CalculatorLibrary ou Calculator é o namespace?
Para resolver a ambiguidade, renomeie o namespace de Calculator para

CalculatorProgram em Program.cs.
C#
namespace CalculatorProgram
Referenciar bibliotecas do .NET: gravar em um
log
Você pode usar a classe Trace do .NET para adicionar um log de todas as operações e
gravá-lo em um arquivo de texto. A classe Trace também é útil para técnicas básicas de
depuração de impressão. A classe Trace está em System.Diagnostics e usa classes
System.IO como StreamWriter .
1. Comece adicionando as diretivas using na parte superior de CalculatorLibrary.cs:
C#
using System.IO;
using System.Diagnostics;
2. Esse uso da classe Trace deve manter uma referência para a classe, que ela associa
a um fluxo de arquivos. Esse requisito significa que a calculadora funciona melhor
como objeto. Portanto, adicione um construtor no início da classe Calculator em
CalculatorLibrary.cs.
Remova também a palavra-chave static para alterar o método estático

DoOperation em um método membro.
C#
public Calculator()
{
StreamWriter logFile = File.CreateText("calculator.log");
Trace.Listeners.Add(new TextWriterTraceListener(logFile));
Trace.AutoFlush = true;
Trace.WriteLine("Starting Calculator Log");
Trace.WriteLine(String.Format("Started {0}",
System.DateTime.Now.ToString()));
}
public double DoOperation(double num1, double num2, string op)

{
3. Adicione a saída de log a cada cálculo. DoOperation agora seria parecida com o
seguinte código:
C#

{
double result = double.NaN; // Default value is "not-a-number" if
an operation, such as division, could result in an error.

switch (op)
{
case "a":
Trace.WriteLine(String.Format("{0} + {1} = {2}", num1,
num2, result));
break;
case "s":
Trace.WriteLine(String.Format("{0} - {1} = {2}", num1,
num2, result));
break;
case "m":
Trace.WriteLine(String.Format("{0} * {1} = {2}", num1,
num2, result));
break;
case "d":
if (num2 != 0)
{
Trace.WriteLine(String.Format("{0} / {1} = {2}", num1,
num2, result));
}
break;
default:
break;
}
return result;
}
4. De volta ao Program.cs, um sublinhado ondulado vermelho agora sinaliza a

chamada estática. Para corrigir o erro, crie uma variável calculator adicionando a
seguinte linha de código pouco antes do loop while (!endApp) :
C#
Calculator calculator = new Calculator();
Modifique também o site de chamada DoOperation para referenciar o objeto

chamado calculator em letras minúsculas. O código agora é uma invocação de
membro, em vez de uma chamada para um método estático.
C#
result = calculator.DoOperation(cleanNum1, cleanNum2, op);
5. Execute o aplicativo novamente. Quando terminar, clique com o botão direito do

mouse no nó de projeto Calculadora e escolha Abrir Pasta no Explorador de
Arquivos.
6. No Explorador de Arquivos, navegue até a pasta de saída em bin/Debug/ e abra o

arquivo calculator.log. A saída deve parecer com esta:
Saída
Starting Calculator Log

Started 7/9/2020 1:58:19 PM
1 + 2 = 3
3 * 3 = 9
Neste ponto, o CalculatorLibrary.cs deve ser semelhante a este código:
C#
using System;
using System.IO;
using System.Diagnostics;
{
{
public Calculator()
{
StreamWriter logFile = File.CreateText("calculator.log");
Trace.Listeners.Add(new TextWriterTraceListener(logFile));
Trace.AutoFlush = true;
Trace.WriteLine("Starting Calculator Log");
Trace.WriteLine(String.Format("Started {0}",
System.DateTime.Now.ToString()));
}

{

switch (op)
{
case "a":
Trace.WriteLine(String.Format("{0} + {1} = {2}", num1,
num2, result));
break;
case "s":
Trace.WriteLine(String.Format("{0} - {1} = {2}", num1,
num2, result));
break;
case "m":
Trace.WriteLine(String.Format("{0} * {1} = {2}", num1,
num2, result));
break;
case "d":
if (num2 != 0)
{
Trace.WriteLine(String.Format("{0} / {1} = {2}",
num1, num2, result));
}
break;
default:
break;
}
return result;
}
}
}
O Program.cs deve ser como o seguinte código:
C#
using System;
{
class Program
{
{

while (!endApp)
{
double result = 0;

{
integer value: ");
}

");
{
integer value: ");
}

list:");
try
{
result = calculator.DoOperation(cleanNum1, cleanNum2,
op);
{
}
result);
}
catch (Exception e)
{
}


}
return;
}
}
}
Adicionar um pacote NuGet: gravar em um

arquivo JSON
Para gerar operações em JSON, um formato popular e portátil para armazenar dados de
objeto, você pode referenciar o pacote NuGet Newtonsoft.Json. Os pacotes NuGet são o
método de distribuição principal para as bibliotecas de classes do .NET.
1. No Gerenciador de Soluções, clique com o botão direito do mouse no nó

Dependências do projeto CalculatorLibrary e escolha Gerenciar Pacotes NuGet.
O Gerenciador de Pacotes NuGet será aberto.

2. Pesquise e selecione o pacote Newtonsoft.Json e selecione Instalar.
O Visual Studio baixa o pacote e adiciona ao projeto. Uma nova entrada será
exibida no nó de Referências no Gerenciador de Soluções.
Adicione uma diretiva using para Newtonsoft.Json no início de

CalculatorLibrary.cs.
C#
using Newtonsoft.Json;
3. Crie o objeto membro JsonWriter e substitua o construtor Calculator pelo

seguinte código:
C#
JsonWriter writer;
public Calculator()
{
StreamWriter logFile = File.CreateText("calculatorlog.json");
logFile.AutoFlush = true;
writer = new JsonTextWriter(logFile);
writer.Formatting = Formatting.Indented;
writer.WriteStartObject();
writer.WritePropertyName("Operations");
writer.WriteStartArray();
}
4. Modifique o método DoOperation para adicionar o código JSON writer :
C#

{
writer.WritePropertyName("Operand1");
writer.WriteValue(num1);
writer.WritePropertyName("Operation");
switch (op)
{
case "a":
writer.WriteValue("Add");
break;
case "s":
writer.WriteValue("Subtract");
break;
case "m":
writer.WriteValue("Multiply");
break;
case "d":
if (num2 != 0)
{
}
writer.WriteValue("Divide");
break;
default:
break;
}
writer.WritePropertyName("Result");
writer.WriteValue(result);
writer.WriteEndObject();
return result;
}
5. Adicione um método para concluir a sintaxe JSON depois que o usuário terminar
de inserir dados de operação.
C#
public void Finish()

{
writer.WriteEndArray();
writer.Close();
}
6. No final de Program.cs, antes do return; , adicione uma chamada a Finish :
C#
// Add call to close the JSON writer before return

calculator.Finish();
return;
}
7. Compile e execute o aplicativo e, depois de concluir a inserção de algumas

operações, feche o aplicativo inserindo o comando n.
8. Abra o arquivo calculatorlog.json no Explorador de Arquivos. Você deverá ver algo
como o seguinte conteúdo:
JSON
{
"Operations": [
{
"Operand1": 2.0,
"Operand2": 3.0,
"Operation": "Add",
"Result": 5.0
},
{
"Operand1": 3.0,
"Operand2": 4.0,
"Operation": "Multiply",
"Result": 12.0
}
]
}
Depurar: definição e ocorrência de um ponto

de interrupção
O depurador do Visual Studio é uma ferramenta eficaz. O depurador pode percorrer seu
código para encontrar o ponto exato em que há um erro de programação. Em seguida,
você pode entender quais correções precisam ser feitas e pode fazer alterações
temporárias para continuar executando seu aplicativo.
1. Em Program.cs, clique na medianiz à esquerda da linha de código a seguir. Você

também pode clicar na linha e selecionar F9 ou clicar com o botão direito do
mouse na linha e selecionar Ponto de Interrupção>Inserir Ponto de Interrupção.
C#
result = calculator.DoOperation(cleanNum1, cleanNum2, op);
O ponto vermelho exibido indica um ponto de interrupção. Você pode usar pontos
de interrupção para pausar seu aplicativo e inspecionar o código. Você pode
definir um ponto de interrupção em qualquer linha de código executável.
2. Compile e execute o aplicativo. Insira os seguintes valores para o cálculo:
Para o primeiro número, insira 8.

Para o segundo número, insira 0.
Para o operador, vamos nos divertir um pouco. Insira d.
O aplicativo suspenderá onde você criou o ponto de interrupção, que é indicado

pelo ponteiro amarelo à esquerda e pelo código realçado. O código realçado
ainda não foi executado.
Agora, com o aplicativo suspenso, você pode inspecionar o estado do aplicativo.
Depurar: exibir variáveis

1. No código realçado, passe o mouse sobre variáveis como cleanNum1 e op . Os
valores atuais dessas variáveis ( 8 e d , respectivamente) são exibidos em DataTips.
Durante a depuração, verificar se as variáveis contêm os valores esperados

geralmente é essencial para corrigir problemas.
2. No painel inferior, examine a janela Locais. Se estiver fechada, selecione

Depurar>Janelas>Locais para abri-la.
A janela Locais mostra cada variável que está atualmente no escopo, juntamente
com o valor e tipo.
3. Dê uma olhada na janela Autos.
A janela Autos é semelhante à janela Locais, mas mostra as variáveis

imediatamente anteriores e posteriores à linha de código atual em que seu
aplicativo está pausado.
７ Observação
Se você não vir a janela Autos, selecione Depurar>Janelas>Autos para abri-la.
Em seguida, execute o código no depurador, uma instrução por vez, o que é chamado
de stepping.
Depurar: passar pelo código

1. Pressione F11 ou selecione Depurar>Intervir.
Usando o comando Intervir, o aplicativo executa a instrução atual e avança para a

próxima instrução executável, geralmente a próxima linha de código. O ponteiro
amarelo à esquerda sempre indica a instrução atual.
Você acabou de intervir no método DoOperation na classe Calculator .
2. Para obter uma análise hierárquica no fluxo do programa, examine a janela Pilha
de Chamadas. Se estiver fechada, selecione Depurar>Janelas>Pilha de Chamadas
para abri-la.
Essa exibição mostra o método atual Calculator.DoOperation , indicado pelo

ponteiro amarelo. A segunda linha mostra a função que chamou o método, do
método Main em Program.cs.
A janela Pilha de Chamadas mostra a ordem em que os métodos e as funções são

chamados. Essa janela também fornece acesso a muitos recursos do depurador,
como Ir para o Código-Fonte, no menu de atalho.
3. Pressione F10 ou selecione Depurar>Step Over várias vezes até que o aplicativo
pause na instrução switch .
C#
switch (op)
{
O comando Step Over é semelhante ao comando Intervir, exceto que, se a

instrução atual chamar uma função, o depurador executará o código na função e
não suspenderá a execução até que a função retorne. O Step Over é mais rápido
do que o Intervir, se você não estiver interessado em uma função específica.
4. Pressione F10 mais uma vez para que o aplicativo pause na linha de código a
seguir.
C#
if (num2 != 0)
{
Esse código verifica se há um caso de divisão por zero. Se continuar, o aplicativo

irá gerar uma exceção geral (um erro), mas talvez você queira tentar algo diferente,
como ver o valor real retornado no console. Uma opção é usar um recurso de
depurador chamado edit-and-continue para fazer alterações no código e continuar
a depuração. No entanto, há um truque diferente para modificar temporariamente
o fluxo de execução.
Depurar: testar uma alteração temporária
1. Selecione o ponteiro amarelo, atualmente pausado na instrução if (num2 != 0) , e
arraste-o para a seguinte instrução:
C#
Arrastar o ponteiro aqui faz com que o aplicativo ignore completamente a

instrução if , para que você possa ver o que acontece quando você divide por
zero.
2. Pressione F10 para executar a linha de código.
3. Se você passar o mouse sobre a variável result . Isso mostrará um valor de

Infinito. No C#, Infinito é o resultado quando você divide por zero.
4. Pressione F5 ou selecione Depurar>Continuar Depuração.
O símbolo de infinito será exibido no console como resultado da operação

matemática.
5. Feche o aplicativo corretamente inserindo o comando n.
Conclusão do código
Este é o código completo para o arquivo CalculatorLibrary.cs, depois de concluir todas
as etapas:
C#
using System;
using System.IO;
using Newtonsoft.Json;
{
{
JsonWriter writer;
public Calculator()
{
StreamWriter logFile = File.CreateText("calculatorlog.json");
logFile.AutoFlush = true;
writer = new JsonTextWriter(logFile);
writer.Formatting = Formatting.Indented;
writer.WritePropertyName("Operations");
writer.WriteStartArray();
}

{
writer.WritePropertyName("Operation");
switch (op)
{
case "a":
writer.WriteValue("Add");
break;
case "s":
writer.WriteValue("Subtract");
break;
case "m":
writer.WriteValue("Multiply");
break;
case "d":
if (num2 != 0)
{
}
writer.WriteValue("Divide");
break;
default:
break;
}
writer.WritePropertyName("Result");
writer.WriteValue(result);
return result;
}
public void Finish()

{
writer.WriteEndArray();
writer.Close();
}
}
}
E este é o código para Program.cs:
C#
using System;
{
class Program
{
{

while (!endApp)
{
double result = 0;

{
integer value: ");
}

");
{
integer value: ");
}

list:");
try
{
result = calculator.DoOperation(cleanNum1, cleanNum2,
op);
{
}
result);
}
catch (Exception e)
{
}


}
calculator.Finish();
return;
}
}
}
Próximas etapas
Parabéns por concluir este tutorial. Para saber mais, continue com o conteúdo a seguir:
Continuar com mais tutoriais do C#
Início rápido: criar um aplicativo Web ASP.NET Core
Aprenda a depurar o código C# no Visual Studio
Explicar como criar e executar testes de unidade
Executar um programa C#
Saiba mais sobre o C# IntelliSense
Continuar com a visão geral do IDE do Visual Studio
Registro em log e rastreamento
Tutorial: Introdução ao C# e ao ASP.NET
Core no Visual Studio
Artigo • 23/11/2023
Neste tutorial para desenvolvimento em C# com o ASP.NET Core, você criará um

aplicativo Web do ASP.NET Core em C# no Visual Studio.
Este tutorial mostra como:
＂ Criar um projeto do Visual Studio

＂ Criar um aplicativo Web C# ASP.NET Core
＂ Fazer alterações no aplicativo Web
＂ Explorar recursos do IDE
＂ Execute o aplicativo Web
Pré-requisitos
Você precisa do Visual Studio para concluir este tutorial. Visite a página de downloads
do Visual Studio para obter uma versão gratuita.
Para obter mais informações sobre como atualizar para a versão mais recente do
Visual Studio, confira Atualizações do Visual Studio.
Para personalizar sua experiência do Visual Studio, confira Personalizar o IDE e o

Editor do Visual Studio.
Criar um projeto
Primeiro, você cria um projeto do ASP.NET Core. O tipo de projeto vem com todos os
arquivos de modelo necessários para criar um site totalmente funcional.

2. Na janela Criar um novo projeto, selecione C# na lista Linguagem. Em seguida,
selecione Windows na lista de plataformas e Web na lista de tipos de projeto.
Depois de aplicar os filtros de linguagem, plataforma e tipo de projeto, selecione o

modelo Aplicativo Web ASP.NET Core e, em seguida, Avançar.
７ Observação
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 você procura? na parte inferior da lista

de modelos, selecione o link Instalar mais ferramentas e recursos.
No Instalador do Visual Studio, selecione ASP.NET e desenvolvimento Web.

necessário salvar o trabalho. Nesse caso, execute essa ação. Selecione
Continuar para instalar a carga de trabalho.
Retorne à etapa 2 neste procedimento "Criar um projeto".
3. Na janela Configurar seu novo projeto, digite MyCoreApp no campo Nome do

projeto. Em seguida, selecione Avançar.
4. Na janela Informações adicionais, verifique se .NET Core 3.1 aparece no campo

Estrutura de Destino.
Nessa janela, você pode habilitar o suporte ao Docker e adicionar suporte à
autenticação. O menu suspenso do Tipo de Autenticação tem as quatro opções a
seguir:
Nenhum: nenhuma autenticação.

Contas individuais: essas autenticações são armazenadas em um banco de
dados local ou baseado no Azure.
Plataforma de identidade da Microsoft: essa opção usa o Microsoft Entra ID
ou o Microsoft 365 para autenticação.
Windows: adequado para aplicativos de intranet.
Deixe a caixa Habilitar Docker desmarcada e selecione Nenhum em Tipo de

Autenticação.
5. Selecione 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 do ASP.NET Core
chamado MyCoreApp. Selecione a guia Gerenciador de Soluções para exibir seu
conteúdo.
2. Expanda a pasta Páginas.
3. Selecione o arquivo Index.cshtml e exiba o arquivo 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 Gerenciador de Soluções e
selecione o arquivo Index.cshtml.cs.
5. Visualize o arquivo Index.cshtml.cs no editor de código.

6. O projeto contém uma pasta wwwroot, que é a raiz do seu site. Expanda a pasta
para exibir seu conteúdo.
Você pode colocar conteúdo de site estático, como CSS, imagens e bibliotecas
JavaScript diretamente nos caminhos onde deseja.
O projeto também contém os arquivos de configuração que gerenciam o

aplicativo web no 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.
7. Expanda o arquivo appsettings.json para exibir o arquivo
appsettings.Development.json.
Executar, depurar e fazer alterações

1. Na barra de ferramentas, selecione o botão IIS Express para compilar e executar o
aplicativo no modo de depuração. Como alternativa, pressione F5 ou vá para
Depurar>Iniciar Depuração na barra de menus.
７ Observação
Se você receber uma mensagem de erro informando Não é possível se

conectar ao servidor Web 'IIS Express', feche o Visual Studio e reinicie o
programa como administrador. Você pode fazer essa tarefa clicando com o
botão direito do mouse no ícone do Visual Studio no Menu Iniciar e
selecionando a opção Executar como administrador no menu de contexto.
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,
selecione Sim e, em seguida, 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 a
Página Inicial e a página Privacidade na barra de menus.
3. Selecione 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 a depuração. Essa
ação fecha o projeto na janela do navegador.
5. No Visual Studio, abra Privacy.cshtml para edição. Em seguida, exclua a frase Use
esta página para detalhar a política de privacidade do site e substitua por Esta
página está em construção a partir de @ViewData["TimeStamp"].
6. Agora, vamos fazer uma alteração de código. Selecione Privacy.cshtml.cs. Em

seguida, limpe as diretivas using na parte superior do arquivo usando o seguinte
atalho:
Diretiva mouseover or select a greyed out using . Uma lâmpada de Ações Rápidas
aparece abaixo do cursor ou na margem esquerda. Selecione a lâmpada e, em
seguida, Remover usings desnecessários.
Agora, selecione Pré-visualizar alterações para ver as alterações.
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:
C#
public void OnGet()

{
string dateTime = DateTime.Now.ToShortDateString();
ViewData["TimeStamp"] = dateTime;
}
8. Observe que um sublinhado ondulado será exibido em DateTime. O sublinhado

ondulado será exibido porque esse 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, vá para Exibir>Lista de Erros
na barra de menus superior.
9. Para corrigir esse erro. No editor de códigos, coloque o cursor na linha que
contém o erro e selecione a lâmpada Ações Rápidas na margem esquerda. No
menu suspenso, selecione 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, selecione Privacidade para ver as alterações.

12. Feche o navegador da Web, pressione Shift+F5 para interromper a depuração.
Alterar a página inicial

1. No Gerenciador de Soluções, expanda a pasta Páginas e, em seguida, selecione
index.cshtml.
O arquivo Index.cshtml corresponde à página Inicial no aplicativo Web, que é

executado em um navegador da Web.
No editor de código, você verá o código HTML para o texto que aparece na página
Página inicial.
2. Substitua o texto Bem-vindo por Olá, Mundo.
3. Selecione IIS Express ou pressione Ctrl+F5 para executar o aplicativo e abri-lo em

um navegador da Web.
4. No navegador da Web, você verá suas novas alterações na página Página inicial.
5. Feche o navegador da Web, pressione Shift+F5 para interromper a depuração e
salve seu projeto. Agora você pode fechar o Visual Studio.
Próximas etapas
Parabéns por concluir este tutorial. Esperamos que você tenha gostado de aprender
sobre o C#, o ASP.NET Core e o IDE do Visual Studio. Para saber mais sobre como criar
um aplicativo Web ou site com C# e ASP.NET, continue com o tutorial a seguir:
Criar um aplicativo Web Páginas Razor com o ASP.NET Core
Ou saiba como colocar seu aplicativo Web em contêineres com o Docker:
Ferramentas de Contêiner no Visual Studio
Confira também
Publicar seu aplicativo Web no Serviço de Aplicativo do Azure usando o Visual Studio
Tutorial: criar seu primeiro aplicativo do
SDK de Aplicativo do Windows no
Visual Studio com XAML e C#
Artigo • 28/04/2023
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 ou posterior. Para fazer isso, você usará um modelo de projeto
do SDK Aplicativo do Windows (WinUI 3), XAML (Extensible Application Markup
Language) e a linguagem de programação C#.
７ Observação
O WinUI 3 é um componente de plataforma da IU nativa fornecido com o SDK do

Aplicativo Windows (completamente separado dos SDKs do Windows). Para obter
mais informações, confira WinUI 3.
Criar um projeto
Primeiro, crie um projeto WinUI 3. O tipo de projeto vem com todos os arquivos de
modelo que você precisa, antes mesmo de você adicionar alguma coisa!
） Importante
O Visual Studio 2019 só dá suporte ao Windows App SDK 1.1 e anterior. O Visual
Studio 2022 é recomendado para desenvolver aplicativos com todas as versões do
Windows App SDK.
Os modelos do SDK de Aplicativo do Windows 1.1.x estão disponíveis instalando uma

VSIX (Extensão do Visual Studio).
７ Observação
Se você tem uma VSIX (Extensão do Visual Studio) do SDK de Aplicativo do
Windows já instalada, desinstale-a antes de instalar uma nova versão. Para obter
instruções, confira Gerenciar extensões para o Visual Studio.
Você pode instalar a última versão estável da VSIX 1.1.x por meio do Visual Studio.
Selecione Extensões>Gerenciar Extensões, pesquise SDK do Aplicativo Windows e
baixe a extensão do SDK do Aplicativo Windows. Feche e reabra o Visual Studio e
siga os prompts para instalar a extensão. Instale os modelos para SDK de
Aplicativo Windows 1.1.
Como alternativa, baixe a extensão diretamente do Visual Studio Marketplace e
instale-a:
Baixar modelos C# de SDK VS2019 do SDK de Aplicativo do Windows
Depois que a extensão de modelos for instalada, você poderá criar seu primeiro projeto.
Para obter mais informações sobre o suporte do Visual Studio 2019, confira Instalar
ferramentas para o SDK de Aplicativo do Windows. No restante deste tutorial,
presumiremos que você tem o Visual Studio 2022 instalado.
1. Abra o Visual Studio e, na janela de início, selecione Criar um novo projeto.
2. Na tela Criar um projeto, digite WinUI na caixa de pesquisa, escolha o modelo C#

para Aplicativo em Branco, Empacotado (WinUI 3 na Área de Trabalho) e escolha
Avançar.
７ Observação
Se você não vir o modelo de projeto Aplicativo em Branco, Empacotado

(WinUI 3 na Área de Trabalho), clique no link Instalar mais ferramentas e
recursos.
O Instalador do Visual Studio é iniciado. Escolha a carga de trabalho

Desenvolvimento da Área de Trabalho do .NET e, no painel de Detalhes da
instalação da caixa de diálogo de instalação, selecione Modelos C# do SDK
de Aplicativo do Windows (na parte inferior da lista). Selecione Modificar.
3. Dê um nome ao projeto, OláMundo, e escolha Criar.

７ Observação
Se esta for a primeira vez que você usa o Visual Studio para criar um
aplicativo do SDK de Aplicativo do Windows, 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, execute 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 MainWindow.xaml para abrir o
editor de marcação XAML.
O Editor de XAML é onde você pode adicionar ou alterar a marcação. Ao contrário

dos projetos UWP, o WinUI 3 não tem uma exibição Design.
2. Examine o controle de Botão aninhado no StackPanel na raiz da Janela.

Alterar o rótulo no botão
1. No Editor de XAML, altere o valor de Conteúdo do Botão de "Clique em min" de
"Olá, Mundo!".
2. Observe que o botão também tem um manipulador de eventos de Clique

chamado myButton_Click especificado. Abordaremos isso na próxima etapa.
Modificar o 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
acionada pelo botão "Olá, Mundo!".
1. No Gerenciador de Soluções, clique duas vezes em MainPage.xaml.cs, na página

code-behind.
2. Edite o código do manipulador de eventos na janela do editor do C# que é aberta.
É aqui que as coisas ficam interessantes. O manipulador de eventos padrão tem

esta aparência:
Vamos alterá-la para que ela tenha esta aparência:
Aqui está o código a ser copiado e colado:
C#
private async void myButton_Click(object sender, RoutedEventArgs e)

{
var welcomeDialog = new ContentDialog()
{
Title = "Hello from HelloWorld",
Content = "Welcome to your first Windows App SDK app.",
CloseButtonText = "Ok",
XamlRoot = myButton.XamlRoot
};
await welcomeDialog.ShowAsync();
}
O que acabamos de fazer?
O código usa o controle ContentDialog para exibir uma mensagem de boas-vindas em

um controle pop-up modal na janela atual. (Para obter mais informações sobre como
usar Microsoft.UI.Xaml.Controls.ContentDialog , confira Classe ContentDialog.)
Executar o aplicativo
É hora de criar, implantar e iniciar o aplicativo do SDK de Aplicativo do Windows "Olá,
Mundo" para ver como ele se comportará. Veja aqui como fazer isso.
1. Use o botão Executar (com o texto OláMundo (Pacote)) 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 esta imagem:
3. Selecione o botão Olá, Mundo.
Seu dispositivo Windows 10 ou posterior exibirá a seguinte mensagem "Bem-

vindo(a) ao seu primeiro aplicativo do SDK de Aplicativo do Windows" com o título
"Olá, do OláMundo". Clique em Ok para fechar a mensagem.
4. Para fechar o aplicativo, selecione o botão Parar Depuração na barra de
ferramentas. (Como alternativa, escolha Depurar>Parar depuração na barra de
menus ou pressione Shift+F5.)
Próximas etapas
Parabéns por concluir este tutorial. Esperamos que você tenha aprendido algumas
noções básicas sobre o SDK de Aplicativo do Windows, WinUI 3 e IDE do Visual Studio.
Para saber mais, continue com o tutorial a seguir:
Tutorial: criar um visualizador de fotos simples com o WinUI 3
Confira também
Criar aplicativos para Windows: como selecionar uma tecnologia de
desenvolvimento
Visão geral do SDK de Aplicativo do Windows
Exemplos do SDK do Aplicativo do Windows/WinUI 3
Tutorial: crie seu primeiro aplicativo da
Plataforma Universal do Windows no
Visual Studio com XAML e C#
Artigo • 02/06/2023
７ Observação
Se você estiver satisfeito com a funcionalidade atual do UWP (Plataforma Universal

do Windows), não será necessário migrar o tipo de projeto para o SDK do
Aplicativo Windows. A WinUI 2.x e o SDK do Windows dão suporte a tipos de
projeto UWP. Caso deseje começar a usar o WinUI 3 e o SDK do Aplicativo
Windows, siga as etapas descritas no tutorial do SDK do Aplicativo Windows.
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 ou posterior. 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#.
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!
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.
７ Observação
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.
７ Observação
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 você não vir a opção Caixa de Ferramentas, poderá abri-la na barra de menus.
Para fazer 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ê examinar o código no Editor XAML, verá que o botão também foi
adicionado lá:
Adicionar um rótulo para o botão

1. No Editor de XAML, altere o valor de Conteúdo do Botão de "Botão" para "Olá,
Mundo!".
2. Observe que o botão no Designer XAML muda muito.

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
ao botã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á-la para que ela tenha esta aparência:

Aqui está o código a ser copiado e colado:
C#
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 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.)
É hora de criar, implantar e iniciar o aplicativo UWP "Olá, Mundo" para ver como ele é e
como ele soa. Veja aqui como fazer isso.
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 ou posterior dirá literalmente "Olá, Mundo!"
4. Para fechar o aplicativo, clique no botão Parar Depuração na barra de ferramentas.

(Como alternativa, escolha Depurar>Parar depuração na barra de menus 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: Criar um aplicativo WPF
simples com C#
Artigo • 23/11/2023
Ao concluir este tutorial, você se familiariza com muitas das ferramentas, caixas de
diálogo e designers que você pode usar ao desenvolver aplicativos com o Visual Studio.
Você cria um aplicativo "Olá, Mundo", cria a interface do usuário, adiciona códigos e
erros de depuração, enquanto aprende a trabalhar no ambiente de desenvolvimento
integrado (IDE).
Pré-requisitos
Se você ainda não tiver instalado o Visual Studio, acesse a página Downloads do
Visual Studio para instalá-lo gratuitamente.
Verifique se você tem a carga de trabalho Desenvolvimento de área de trabalho
do .NET instalada. Você pode verificar essa configuração no Instalador do Visual
Studio.
Você pode usar o .NET Framework ou o .NET Core para este tutorial. O .NET Core é
a estrutura mais recente e moderna. O .NET Core exige o Visual Studio 2019 versão
16.3 ou posterior.
O que é o WPF?
O WPF (Windows Presentation Foundation) é uma estrutura de interface do usuário que
cria aplicativos cliente da área de trabalho. A plataforma de desenvolvimento WPF dá
suporte a um amplo conjunto de recursos de desenvolvimento de aplicativos, incluindo
um modelo de aplicativo, recursos, controles, gráficos, layouts, associação de dados,
documentos e segurança.
O WPF faz parte do .NET; portanto, se você tiver criado aplicativos anteriormente com o
.NET usando o ASP.NET ou o Windows Forms, a experiência de programação deverá ser
conhecida. O WPF usa a linguagem XAML para fornecer um modelo declarativo para
programação de aplicativos. Para obter mais informações, confira Visão geral do WPF
.NET.
Configurar o IDE
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ê vê janelas de
ferramentas, menus e barras de ferramentas e o espaço principal da janela. As janelas de
ferramentas são encaixadas à esquerda e à direita da janela do aplicativo. A caixa de
pesquisa, a barra de menus e a barra de ferramentas padrão estã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ê passa a
maior parte do 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ê cria um projeto do Windows Presentation Foundation (WPF).
2. Na tela Iniciar, selecione Criar projeto.
3. Na tela Criar um projeto, pesquise por "WPF" e escolha Aplicativo WPF e, em

seguida, escolha Avançar.
4. Na próxima tela, dê o nome HelloWPFApp ao projeto e escolha Avançar.
5. Na janela Informações adicionais, o .NET Core 3.1 já deve estar selecionado para
sua estrutura de destino. Caso contrário, selecione .NET Core 3.1. Em seguida,
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.
７ Observação
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.
Criar a interface do usuário

Se o designer não estiver aberto, selecione MainWindow.xaml e pressione Shift+F7 para
abrir o designer.
Adicionamos 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 digite 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 posteriores,
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:
XAML
<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:
XAML
<Grid>
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, adicione 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, você adiciona 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 Conteúdo para os dois botões de opção HelloButton e
GoodbyeButton para "Hello" e "Goodbye" no XAML. A marcação XAML deve agora
ser semelhante ao exemplo a seguir:
XAML
<Grid>
<RadioButton x:Name="HelloButton" Content="Hello"
HorizontalAlignment="Left" Margin="297,161,0,0"
VerticalAlignment="Top"/>
<RadioButton x:Name="GoodbyeButton" Content="Goodbye"
</Grid>
Definir que um botão de opção faça check-in por padrão

Nesta etapa, definimos HelloButton para ser verificado por padrão para 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:
XAML
<Grid>
<RadioButton x:Name="HelloButton" Content="Hello" IsChecked="True"
</Grid>
O elemento final da interface do usuário que você adiciona é 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 ajudará 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:
XAML
<Grid>
<RadioButton x:Name="HelloButton" Content="Hello" IsChecked="True"
<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 aparece para Olá e outra aparece para Até logo. Para criar esse
comportamento, adicione código ao evento Button_Click em MainWindow.xaml.cs.
1. Na superfície de design, clique duas vezes no botão Exibição.
MainWindow.xaml.cs é aberto, com o cursor no evento Button_Click .
C#
private void Button_Click(object sender, RoutedEventArgs e)
{
2. Insira o seguinte código:
C#
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ê depura o aplicativo para procurar erros e testar se ambas as caixas de
mensagem aparecem 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.
Alterar o nome de MainWindow.xaml

Vamos dar um nome mais específico para MainWindow. Em Gerenciador de Soluções,
clique com o botão direito do mouse em MainWindow.xaml e escolha Renomear.
Renomeie o arquivo para Greetings.xaml.
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 do Modo de interrupção é exibida e a janela Saída indica que ocorreu
um IOException: não é possível localizar o recurso mainwindow.xaml.
2. Interrompa o depurador escolhendo Depurador>Interromper a Depuração.
Renomeamos o MainWindow.xaml como Greetings.xaml, 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.
Como uma etapa opcional, evita confusão ao alterar o título da janela do aplicativo para
corresponder a esse novo nome.
1. No Gerenciador de Soluções, abra o arquivo Greetings.xaml que você acabou de

renomear.
2. Altere o valor da propriedade Window.Title de Title="MainWindow" para

Title="Greetings" e salve as alterações.
Inicie o depurador novamente (pressione F5). Você agora deverá ver a janela Saudações
do seu 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
Depurar>Ativar/Desativar Ponto de Interrupção, clicando na margem esquerda do
editor ao lado da linha de código em que você deseja que a interrupção ocorra ou
pressionando F9.
Adicionar pontos de interrupção
1. Abra Greetings.xaml.cs e 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 menus, escolha Depurar>Depuração Circular.
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 menus, escolha Depurar>Desabilitar Todos os Pontos de Interrupção.
Exibir uma representação dos elementos da interface do

usuário
No aplicativo em execução, você deverá ver um widget que aparece na parte superior
da janela. O widget é um auxiliar de runtime que fornece acesso rápido a alguns
recursos úteis de depuração. Selecione o primeiro botão, Acessar Árvore Visual
Dinâmica. Você deve ver uma janela com uma árvore que contém todos os elementos
visuais da sua página. Expanda os nós para localizar os botões que você adicionou.
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>Limpar solução para excluir arquivos

intermediários e arquivos de saída criados durante builds anteriores. Essa etapa
não é necessária, mas limpa as saídas de build de depuração.
2. Altere a configuração de build de HelloWPFApp, de Depuração para Versão,
usando o controle suspenso na barra de ferramentas (no momento, seu nome é
“Depuração”).
3. Compile a solução escolhendo Compilar>Compilar solução.
Parabéns por concluir este tutorial. Encontre o .exe compilado na solução e no diretório
do 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
Comentários
Esta página foi útil?  Yes  No
Criar um aplicativo do Windows Forms
no Visual Studio com C#
Artigo • 17/03/2023
Neste tutorial, você criará um aplicativo simples do C# que tem uma interface do
usuário baseada em Windows.
７ Observação
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.
2. Na tela Iniciar, selecione Criar um novo projeto.

3. Na janela Criar um novo projeto, escolha o modelo Aplicativo do Windows Forms
(.NET Framework) para C#.
(Se preferir, você pode refinar sua pesquisa para acessar rapidamente o modelo
desejado. Por exemplo, insira ou digite Aplicativo do Windows Forms na caixa de
pesquisa. Em seguida, escolha C# na lista Linguagem e escolha Windows na lista
Plataforma.)
７ Observação
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 a carga de trabalho

Desenvolvimento de desktop 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 seguida, escolha Criar.
Criar o aplicativo
Depois de selecionar o seu modelo de projeto do C# e nomear seu arquivo, o Visual
Studio abrirá um formulário para você. Um formulário é uma interface do usuário do
Windows. Vamos criar um aplicativo "Olá, Mundo" ao adicionar controles ao formulário
e, em seguida, vamos executar 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 enxergar a opção de submenu Caixa de Ferramentas, poderá abri-la
na barra de menus. Para fazer isso, Exibir>Caixa de Ferramentas. Ou pressione
Ctrl+Alt+X.)
2. Escolha o ícone Fixar para encaixar a janela Caixa de Ferramentas.
3. Escolha o controle Botão e, em seguida, arraste-o para o formulário.

4. Na janela Propriedades, localize Texto, altere o nome de Button1 para Click this
e, em seguida, pressione Enter.
(Se você não enxergar a janela Propriedades, poderá abri-la na barra de menus.
Para fazer 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.
７ Observação
Se a lista estiver em ordem alfabética na janela Propriedades, como

alternativa, o Button1 aparecerá na seção (DataBindings).
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 aqui para abrir a
janela Form1.cs.
(Como alternativa, você pode expandir Form1.cs em Gerenciador de Soluções e,

em seguida, escolher Exibir Código(ou pressionar F7) no menu exibido com o
clique do botão direito do mouse em Form1.cs.)
2. Na janela Form1.cs, após a linha private void, digite ou insira lblHelloWorld.Text =

"Hello World!"; 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 aqui 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
Parabéns por concluir este tutorial. Para saber mais, continue com o tutorial a seguir:
Tutorial: Criar um visualizador de imagens
Confira também
Mais tutoriais do C#
Tutoriais sobre o Visual Basic
Tutoriais do C++
Tutorial: Criar um aplicativo de
visualizador de imagens do Windows
Forms no Visual Studio
Artigo • 21/06/2023
Nesta série de três tutoriais, você irá criar um aplicativo do Windows Forms que carrega
uma imagem e a exibe. O IDE (Ambiente de design Integrado) do Visual Studio fornece
as ferramentas necessárias para criar o aplicativo. Para saber mais, confira Bem-vindo ao
IDE do Visual Studio.
Neste primeiro tutorial, você aprenderá a:
＂ Criar um projeto do Visual Studio que usa o Windows Forms

＂ Adicione um elemento do layout
＂ Execute seu aplicativo.
Pré-requisitos
Criar seu projeto do Windows Forms

Ao criar um visualizador de imagens, a primeira etapa é criar um projeto de aplicativo
do Windows Forms.

3. Na janela Criar um projeto, pesquise Windows Forms. Em seguida, selecione Área
de Trabalho na lista Tipo de projeto.
4. Selecione o modelo Windows Forms App (.NET Framework) para C# ou Visual

Basic e, em seguida, selecione Avançar.
７ Observação
Framework), pode instalá-lo a partir da janela Criar um novo projeto. Na
mensagem Não encontrou o que precisa?, selecione o link Instalar mais
Em seguida, no Instalador do Visual Studio, selecione Desenvolvimento da

área de trabalho do .NET.

necessário salvar o trabalho. Nesse caso, execute essa ação. Em seguida,
selecione Continuar para instalar a carga de trabalho.
5. Na janela Configurar seu novo projeto, dê ao projeto o nome PictureViewer, e, em

seguida, selecione Criar.
O Visual Studio cria uma solução para seu aplicativo. Uma solução é um contêiner para
todos os projetos e arquivos necessários pelo seu aplicativo.
Neste ponto, o Visual Studio exibe um formulário vazio no Designer de Formulários do

Windows.
Adicione um elemento do layout

Seu aplicativo de exibição de imagem contém uma caixa de imagem, uma caixa de
seleção e quatro botões, que você adicionará no próximo tutorial. O elemento de layout
controla sua localização no formulário. Esta seção mostra como alterar o título do
formulário, redimensioná-lo e adicionar um elemento de layout.
1. Em seu projeto, selecione o Designer de Formulários do Windows. A guia lê

Form1.cs [Design] para C# ou Form1.vb [Design] para Visual Basic.
2. Selecione qualquer lugar no Form1.
3. A janela Propriedades agora exibe as propriedades para o formulário. A janela

Propriedades geralmente está no canto inferior direito do Visual Studio. Esta seção
controla várias propriedades, como a cor de primeiro plano e do plano de fundo, o
texto do título que aparece na parte superior do formulário e o tamanho do
formulário.
Se Propriedades não for exibido, selecione Exibir>Janela Propriedades.
4. Localize a propriedade Texto na janela Propriedades. Dependendo de como a lista

estiver classificada, talvez seja necessário rolar para baixo. Insira o valor
Visualizador de Imagens e escolha Enter.
O formulário agora tem o texto Visualizador de Imagens na barra de título.
７ Observação
Você pode exibir as propriedades por categoria ou em ordem alfabética. Use

os botões na janela Propriedades para alternar para frente e para trás.
5. Selecione o formulário novamente. Selecione a alça de arrastar no canto inferior

direito do formulário. A alça é um quadrado branco pequeno no canto inferior
direito do formulário.
Arraste a alça para redimensionar o formulário para que o formulário fique mais
amplo e um pouco mais alto. Se você examinar a janela Propriedades, a
propriedade Size foi alterada. Você também pode alterar o tamanho do formulário
alterando a propriedade Size.
6. No lado esquerdo do IDE do Visual Studio, selecione a guia Caixa de Ferramentas.

Se não aparecer, selecione Exibir>Caixa de Ferramentas na barra de menus ou
Ctrl+Alt+X.
7. Selecione o símbolo de triângulo pequeno ao lado de Contêineres para abrir o
grupo.
8. Clique duas vezes em TableLayoutPanel na caixa de ferramentas. Você também

pode arrastar um controle da caixa de ferramentas para o formulário. O controle
TableLayoutPanel aparece em seu formulário.
７ Observação
Após adicionar seu TableLayoutPanel, se uma janela aparecer no formulário

com o título Tarefas de TableLayoutPanel, clique em qualquer lugar dentro
do formulário para fechá-la.
9. Selecione TableLayoutPanel. Você pode verificar qual controle está selecionado

examinando a janela Propriedades.
10. Com TableLayoutPanel selecionado, localize a propriedade Dock, que tem o valor
None. Selecione a seta suspensa e, em seguida, selecione Preenchimento, que é o
botão grande no meio do menu suspenso.
Encaixe refere-se a como uma janela é anexada a outra janela ou área.
TableLayoutPanel agora preenche todo o formulário. Se você redimensionar o

formulário novamente, o TableLayoutPanel permanecerá anexado e se
redimensionará para caber.
11. No formulário, selecione TableLayoutPanel. No canto superior direito, há um

pequeno botão de triângulo preto.
Selecione o triângulo para exibir a lista de tarefas do controle.

12. Selecione Editar Linhas e Colunas para exibir a caixa de diálogo Estilos de Coluna
e Linha.
13. Selecione Column1 e defina seu tamanho como 15%. Verifique se o botão
Porcentagem está selecionado.
14. Selecione Column2 e defina-a como 85%.
15. Em Mostrar na parte superior da caixa de diálogo Estilos de Coluna e Linha,

selecione Linhas. Defina Row1 como 90% e Row2 como 10%. Selecione OK para
salvar suas alterações.
O TableLayoutPanel agora tem uma grande primeira linha, uma pequena linha
inferior, uma pequena coluna esquerda, e uma grande coluna direita.
Seu layout está completo.
７ Observação
Antes de executar seu aplicativo, salve seu aplicativo escolhendo o botão de barra
de ferramentas Salvar Tudo. Como alternativa, para salvar seu aplicativo, escolha
Arquivo>Salvar Tudo na barra de menus ou pressione Ctrl+Shift+S. É uma prática
recomendada salvar no início e com frequência.
Ao criar um projeto do aplicativo do Windows Forms, você compila um programa que é
executado. Nesta fase, seu aplicativo Visualizador de Imagens não faz muita coisa. Por
enquanto, ele exibe uma janela vazia que mostra Visualizador de Imagens na barra de
título.
Para executar o aplicativo, siga estas etapas.
1. Use um dos métodos a seguir:
Selecione a tecla F5.

Na barra de menus, selecione Depurar>Iniciar Depuração.
Na barra de ferramentas, selecione o botão Iniciar.
O Visual Studio executa seu aplicativo. Uma janela com o título Visualizador de
Imagens é exibida.
Veja o IDE da barra de ferramentas do Visual Studio. Mais botões aparecem na
barra de ferramentas quando você executa um aplicativo. Esses botões permitem
fazer coisas como parar e iniciar seu aplicativo, e ajudam você a rastrear erros.
2. Use um dos seguintes métodos para pausar seu aplicativo:
Na barra de ferramentas, selecione o botão Parar Depuração.

Na barra de menus, selecione Depurar>Parar Depuração.
No teclado, insira Shift+F5.
Selecione X no canto superior da janela Visualizador de Imagens.
Quando você executa seu aplicativo no IDE do Visual Studio, isso é chamado de
depuração. Você executa seu aplicativo para localizar e corrigir bugs. Você segue o
mesmo procedimento para executar e depurar outros programas. Para saber mais
sobre depuração, confira Introdução ao depurador.
Próximas etapas
Avance para o próximo tutorial para saber como adicionar controles ao programa
Visualizador de Imagens.
Parte 2 do Tutorial: Adicionar controles ao Visualizador de Imagens

Tutorial: Adicionar controles de
interface do usuário ao visualizador de
imagens Windows Forms aplicativo no
Visual Studio
Artigo • 19/06/2023
as ferramentas necessárias para criar o aplicativo. Para saber mais, confira Bem-vindo ao
IDE do Visual Studio.
Este programa tem uma caixa de seleção, uma caixa de seleção e vários botões, que
você usa para controlar o aplicativo. Este tutorial mostra como adicionar esses controles.
Neste segundo tutorial, você aprenderá como:
＂ Adicionar controles ao seu aplicativo

＂ Adicionar botões em um painel de layout
＂ Alterar nomes e locais de controle
＂ Adicionar componentes de diálogo
Pré-requisitos
Este tutorial se baseia no tutorial anterior, Criar um aplicativo de visualizador de
imagens. Se você ainda não fez esse tutorial, passe por ele primeiro.
Adicionar controles ao seu aplicativo

O aplicativo Visualizador de Imagens usa um controle PictureBox para exibir uma
imagem. Ele usa uma caixa de seleção e vários botões para gerenciar a imagem e a tela
de fundo e fechar o aplicativo. Você adicionará a PictureBox e uma caixa de seleção da
Caixa de Ferramentas no IDE do Visual Studio.
1. Abra o Visual Studio. Seu projeto visualizador de imagens aparece em Abrir

recente.
2. No Designer de Formulários do Windows, selecione o TableLayoutPanel que você
adicionou no tutorial anterior. Verifique se tableLayoutPanel1 aparece na janela
Propriedades.

Ctrl+Alt+X. Na caixa de ferramentas, expanda Controles Comuns.
4. Clique duas vezes em PictureBox para adicionar um controle PictureBox ao seu

formulário. O IDE do Visual Studio adiciona o controle PictureBox à primeira célula
vazia do TableLayoutPanel.
5. Escolha o novo controle PictureBox para selecioná-lo, e então selecione o

triângulo preto no novo controle PictureBox para exibir a lista de tarefas.
6. Selecione Encaixar no Contêiner Pai, que define a propriedade PictureBox Dock

como Fill. Você pode ver esse valor na janela Propriedades.
7. Na janela Propriedades da PictureBox, defina a propriedade ColumnSpan como 2.

A PictureBox agora preenche ambas as colunas.
8. Defina a propriedade BorderStyle como Fixed3D.
9. No Designer de Formulários do Windows, selecione o TableLayoutPanel. Em

seguida, na Caixa de Ferramentas, clique duas vezes no item CheckBox para
adicionar um novo controle CheckBox. Seu PictureBox ocupa as duas primeiras
células em TableLayoutPanel, então o controle de caixa de seleção é adicionado à
célula do canto inferior esquerdo.
10. Escolha a propriedade Texto e insira Stretch.

Adicionar botões em um painel de layout
Os controles até agora foram adicionados ao TableLayoutPanel. Estas etapas mostram
como adicionar quatro botões a um novo painel de layout no TableLayoutPanel.
1. Selecione TableLayoutPanel no formulário. Abra a Caixa de Ferramentas e

selecione Contêineres. Clique duas vezes em FlowLayoutPanel para adicionar um
novo controle à última célula do TableLayoutPanel.
2. Defina a propriedade Dock do FlowLayoutPanel para Fill. Você pode definir essa
propriedade selecionando o triângulo preto e, em seguida, selecionando Encaixar
no contêiner pai.
Um FlowLayoutPanel é um contêiner que organiza outros controles em uma linha,

um após o outro.
3. Selecione o novo FlowLayoutPanel, abra a Caixa de Ferramentas e selecione

Controles Comuns. Clique duas vezes no item Botão para adicionar um controle
de botão chamado button1.
4. Clique duas vezes em Botão novamente para adicionar outro botão. O IDE chama
o próximo de button2.
5. Adicione mais dois botões dessa maneira. Outra opção é selecionar button2 e, em
seguida, selecionar Editar>Copiar ou pressionar Ctrl+C. Em seguida, escolha
Editar>Colar na barra de menus ou pressione Ctrl+V. Para colar uma cópia do
botão. Agora cole-o novamente. Observe que o IDE adiciona button3 e button4
ao FlowLayoutPanel.
6. Selecione o primeiro botão e defina sua propriedade Text como Show a picture.
7. Defina as propriedades Text dos próximos três botões como Limpar a imagem,
Definir a cor da tela de fundo e Fechar.
8. Para dimensionar os botões e organizá-los, selecione FlowLayoutPanel. Defina a

propriedade FlowDirection como RightToLeft.
Os botões devem alinhar-se para o lado direito da célula e reverter a ordem de

modo que o botão Mostrar uma imagem fique à direita. Você pode arrastar os
botões ao redor do FlowLayoutPanel para organizá-los em qualquer ordem.
9. Escolha o botão Fechar para selecioná-lo. Em seguida, para escolher o restante

dos botões ao mesmo tempo, pressione e segure a tecla Ctrl e escolha-os
também.
10. Na janela Propriedades, defina a propriedade AutoSize como True. Os botões
redimensionam para se ajustarem ao texto.
Você pode executar seu programa para ver a aparência dos controles. Selecione a tecla
F5, selecione Depurar>Iniciar Depuração ou selecione o botão Iniciar. Os botões que
você adicionou ainda não fazem nada.
Alterar nomes de controle

Há quatro botões no seu formulário, chamdos de button1, button2, button3 e button4.
No Visual Basic, a primeira letra padrão de qualquer nome de controle é maiúscula,
portanto, os botões são nomeados Button1, Button2, Button3 e Button4. Use essas
etapas para dar a eles nomes mais informativos.
1. No formulário, clique no botão Fechar. Se você ainda tiver todos os botões

selecionados, pressione Esc para cancelar a seleção.
2. Na janela Propriedades, procure por (Name). Altere o nome para closeButton.
O IDE não aceita nomes que contenham espaços.
3. Renomeie os outros três botões para backgroundButton, clearButton e

showButton. Você pode verificar os nomes escolhendo a lista suspensa seletora de
controle na janela Propriedades. Os nomes dos novos botões aparecem.
Você pode alterar o nome de qualquer controle, como TableLayoutPanel ou caixa de
seleção.
Adicionar componentes de diálogo

Seu aplicativo pode abrir arquivos de imagem e escolher uma cor da tela de fundo
usando componentes. Um componente é como um controle. Use a Caixa de
ferramentas para adicionar um componente ao formulário. Defina os valores de
propriedade usando a janela Propriedades.
Ao contrário de um controle, adicionar um componente ao formulário não adiciona um

item visível. Em vez disso, fornece determinados comportamentos que você pode
disparar com código. Por exemplo, é um componente que abre uma caixa de diálogo
Abrir Arquivo.
Nesta seção, você adicionará um componente OpenFileDialog e um componente

ColorDialog ao formulário.
1. Selecione oDesigner de Formulários do Windows (Form1.cs [Design]). Em

seguida, abra a Caixa de Ferramentas e selecione o grupo Caixas de Diálogo.
2. Clique duas vezes em OpenFileDialog para adicionar um componente chamado

openFileDialog1 ao seu formulário.
3. Clique duas vezes em ColorDialog para adicionar um componente chamado

colorDialog1. Os componentes aparecem na parte inferior do Designer de
formulários do Windows como ícones.
4. Escolha o ícone openFileDialog1 e defina duas propriedades:
Defina a propriedade Filter para o seguinte:
Console
JPEG Files (*.jpg)|*.jpg|PNG Files (*.png)|*.png|BMP Files

(*.bmp)|*.bmp|All files (*.*)|*.*
Defina a propriedade Título como o seguinte: Selecionar um arquivo de
imagem
As configurações da propriedade Filtro especificam os tipos de arquivo que a caixa

de diálogo do arquivo Selecionar uma imagem exibe.
Próximas etapas
Siga para o próximo tutorial para saber como adicionar código ao seu aplicativo.
Parte 3 do Tutorial: Adicionar código ao Visualizador de Imagens

Tutorial: Adicionar código ao aplicativo
visualizador de imagens do Windows
Forms no Visual Studio
Artigo • 18/03/2023
as ferramentas necessárias para criar o aplicativo. Para saber mais, confira Bem-vindo(a)
ao IDE do Visual Studio.
Os controles usam código C# ou Visual Basic para executar as ações associadas a eles.
Neste terceiro tutorial, você aprenderá como:
＂ Adicionar manipuladores de eventos para seus controles

＂ Escrever código para abrir uma caixa de diálogo
＂ Escrever código para os outros controles
＂ Execute seu aplicativo.
Pré-requisitos
Este tutorial se baseia nos tutoriais anteriores, Criar um aplicativo de visualizador de
imagens e Adicionar controles de interface do usuário ao visualizador de imagens. Se
você ainda não fez esses tutoriais, passe por eles primeiro.
Adicionar manipuladores de eventos para seus

controles
Nesta seção, adicione manipuladores de eventos para os controles que você adicionou
no segundo tutorial, Adicionar controles a um aplicativo visualizador de imagens. Seu
aplicativo chama um manipulador de eventos quando ocorre uma ação, como
selecionar um botão.
1. Abra o Visual Studio. Seu projeto visualizador de imagens aparece em Abrir

recente.
2. Acesse o Designer de Formulários do Windows e clique duas vezes no botão
Mostrar uma imagem. Em vez disso, você pode selecionar o botão Mostrar uma
imagem no formulário e pressionar Enter.
O IDE do Visual Studio abre uma guia na janela principal. Para C#, a guia é
denominada Form1.cs. Se você estiver usando o Visual Basic, a guia será
denominada Form1.vb.
Essa guia exibe o arquivo de código por trás do formulário.
７ Observação
Sua guia Form1.vb pode exibir showButton como ShowButton.
3. Foco nesta parte do código.
C#
C#
private void showButton_Click(object sender, EventArgs e)

{
}
） Importante
Use o controle da linguagem de programação no canto superior direito desta

página para exibir os snippets de código C# ou do Visual Basic.
4. Escolha a guia Designer de Formulários do Windows novamente e clique duas

vezes no botão Limpar a imagem para abrir o código dela. Repita isso para os dois
botões restantes. A cada vez, o IDE do Visual Studio adiciona um novo método ao
arquivo de código do formulário.
5. Clique duas vezes no controle CheckBox no Designer de Formulários do Windows

para adicionar um método checkBox1_CheckedChanged() . Quando você marca ou
desmarca a caixa de seleção, ela chama esse método.
O snippet de código a seguir mostra o novo código que você vê no editor de

código.
C#
C#
private void clearButton_Click(object sender, EventArgs e)

{
}
private void backgroundButton_Click(object sender, EventArgs e)

{
}
private void closeButton_Click(object sender, EventArgs e)

{
}
private void checkBox1_CheckedChanged(object sender, EventArgs e)

{
}
Métodos, incluindo manipuladores de eventos, podem ter qualquer nome desejado.

Quando você adiciona um manipulador de eventos com o IDE, cria um nome com base
no nome do controle e do evento que está sendo tratado.
Por exemplo, o evento Click de um botão chamado showButton é chamado de

showButton_Click() ou ShowButton_Click() . Se você quiser alterar um nome de variável
de código, clique com o botão direito do mouse na variável no código e então escolha
Refatorar>Renomear. Todas as instâncias desta variável no código são renomeadas.
Para obter mais informações, confira Refatoração de renomeação.
Escrever código para abrir uma caixa de

diálogo
O botão Mostrar uma imagem usa o componente OpenFileDialog para exibir um
arquivo de imagem. Este procedimento adiciona o código usado para chamar esse
componente.
O IDE do Visual Studio oferece uma ferramenta poderosa chamada IntelliSense.

Conforme você digita, o IntelliSense sugere um código possível.
1. No Designer de Formulários do Windows, clique duas vezes no botão Mostrar

uma imagem. O IDE move o cursor para dentro do método showButton_Click()
ou ShowButton_Click() .
2. Digite i na linha vazia entre as duas chaves { } ou entre Private Sub... e End Sub .
Uma janela do IntelliSense é aberta.
3. A janela do IntelliSense deve estar realçando a palavra if . Selecione a tecla Tab
para inserir if .
4. Selecione true e digite op para substituí-lo para C# ou Op para Visual Basic.
O IntelliSense exibe openFileDialog1.
5. Selecione Tab para adicionar openFileDialog1.
6. Digite um ponto final ( . ) ou ponto, logo após openFileDialog1. O IntelliSense

fornece todas as propriedades e métodos do componente OpenFileDialog.
Comece a digitar ShowDialog e selecione Tab. O método ShowDialog() mostrará a
caixa de diálogo Abrir Arquivo.
7. Adicione parênteses () imediatamente após o "g" em ShowDialog . Seu código

deve ser openFileDialog1.ShowDialog() .
8. Para o C#, adicione um espaço e, em seguida, adicione dois sinais de igual ( == ).

Para o Visual Basic, adicione um espaço e, em seguida, use um único sinal de igual
( = ).
9. Adicionar outro espaço. Use o IntelliSense para inserir DialogResult.
10. Digite um ponto para abrir o valor DialogResult na janela do IntelliSense. Insira a
letra O e pressione a tecla Tab para inserir OK.
７ Observação
A primeira linha de código deve ser preenchida. Para C#, ele deve ser
semelhante ao mostrado a seguir.
if (openFileDialog1.ShowDialog() == DialogResult.OK)
Para o Visual Basic, deve ser o seguinte.
If OpenFileDialog1.ShowDialog() = DialogResult.OK Then
11. Adicione a linha de código a seguir.

C#
C#
pictureBox1.Load(openFileDialog1.FileName);
Você pode copiar e colar ou usar o IntelliSense para adicioná-la. Agora o método
showButton_Click() deve estar semelhante ao código a seguir.
C#
C#

{
{
}
}
1. Adicione o seguinte comentário ao seu código.
C#
C#

{
// Show the Open File dialog. If the user clicks OK, load the
// picture that the user chose.
{
}
}
A melhor prática é sempre comentar seu código. Os comentários de código facilitam a

compreensão e a manutenção futuras do código.
Escrever código para os outros controles
Se você executar seu aplicativo agora, poderá selecionar Mostrar uma imagem. O
Visualizador de Imagens abre a caixa de diálogo Abrir Arquivo, na qual você pode
selecionar uma imagem a ser exibida.
Nesta seção, adicione o código para os outros manipuladores de eventos.
1. No Designer de Formulários do Windows, clique duas vezes no botão Limpar a

imagem. Adicione o código entre as chaves.
C#
C#
private void clearButton_Click(object sender, EventArgs e)

{
// Clear the picture.
pictureBox1.Image = null;
}
2. Clique duas vezes no botão Definir a cor da tela de fundo e adicione o código
entre chaves.
C#
C#
private void backgroundButton_Click(object sender, EventArgs e)

{
// Show the color dialog box. If the user clicks OK, change the
// PictureBox control's background to the color the user chose.
if (colorDialog1.ShowDialog() == DialogResult.OK)
pictureBox1.BackColor = colorDialog1.Color;
}
3. Clique duas vezes no botão Fechar e adicione o código entre chaves.
C#
C#
private void closeButton_Click(object sender, EventArgs e)
{
// Close the form.
this.Close();
}
4. Clique duas vezes na caixa de seleção Stretch e adicione o código entre chaves.
C#
C#
private void checkBox1_CheckedChanged(object sender, EventArgs e)

{
// If the user selects the Stretch check box,
// change the PictureBox's
// SizeMode property to "Stretch". If the user clears
// the check box, change it to "Normal".
if (checkBox1.Checked)
pictureBox1.SizeMode = PictureBoxSizeMode.StretchImage;
else
pictureBox1.SizeMode = PictureBoxSizeMode.Normal;
}
Execute seu aplicativo.

Você poderá executar seu aplicativo a qualquer momento enquanto o estiver
escrevendo. Depois de adicionar o código na seção anterior, o Visualizador de Imagens
estará concluído. Como nos tutoriais anteriores, use um dos seguintes métodos para
executar seu aplicativo:
Selecione a tecla F5.

Na barra de menus, selecione Depurar>Iniciar Depuração.
Uma janela com o título Visualizador de Imagens é exibida. Teste todos os controles.
1. Selecione o botão Definir a cor da tela de fundo. A caixa de diálogo Cor é aberta.
2. Escolha uma cor para definir a cor da tela de fundo.
3. Selecione Mostrar uma imagem para exibir uma imagem.
4. Selecione e desmarque Alongar.
5. Selecione o botão Limpar a imagem para garantir que a exibição seja limpa.
6. Selecione Fechar para sair do aplicativo.
Próximas etapas
Parabéns! Você concluiu esta série de tutoriais. Você concluiu estas tarefas de
programação e design no IDE do Visual Studio:
Criou um projeto do Visual Studio que usa o Windows Forms

Layout adicionado ao aplicativo de exibição de imagens
Adicionou botões e uma caixa de seleção
Adicionou caixas de diálogo
Adicionou manipuladores de eventos para seus controles
Gravou um código C# ou Visual Basic para manipular os eventos
Continue aprendendo com outra série de tutoriais sobre como criar um teste de
matemática cronometrado.
Tutorial 2: criar um teste de matemática cronometrado

Tutorial: Criar um aplicativo WinForms
de teste de matemática
Artigo • 19/06/2023
Nesta série de quatro tutoriais, você criará um teste de matemática. O teste contém
quatro problemas matemáticos aleatórios que um participante do teste tentará
responder em um tempo especificado.
O IDE (ambiente de desenvolvimento integrado) do Visual Studio fornece as

ferramentas necessárias para criar o aplicativo. Para saber mais sobre esse IDE, confira
Bem-vindo ao IDE do Visual Studio.
＂ Crie um projeto do Visual Studio que usa o Windows Forms.

＂ Adicione rótulos, um botão e outros controles a um formulário.
＂ Defina propriedades para os controles.
＂ Salve e execute seu projeto.
Pré-requisitos
Crie seu projeto do Windows Forms

Ao criar um teste de matemática, a primeira etapa é criar um projeto de aplicativo do
Windows Forms.

de Trabalho na lista Tipo de projeto.

７ Observação


soclitado que você salve o trabalho. Nesse caso, execute essa ação. Em
seguida, selecione Continuar para instalar a carga de trabalho.
5. Na janela Configurar seu novo projeto, dê ao projeto o nome MathQuiz, e, em

seguida, selecione Criar.
todos os projetos e arquivos de que seu aplicativo precisa.
Definir propriedades do formulário

Depois de selecionar o modelo de projeto e nomear seu arquivo, o Visual Studio abrirá
um formulário para você. Essa seção mostra como alterar algumas propriedades do
formulário.
1. Em seu projeto, selecione o Designer de Formulários do Windows. A guia

designer é rotulada como Form1.cs [Design] para C# ou Form1.vb [Design] para
Visual Basic.
2. Selecione o formulário Form1.
3. A janela Propriedades agora exibe as propriedades do formulário. Essa janela

geralmente fica no canto inferior direito do Visual Studio. Se Propriedades não for
exibido, selecione Exibir>Janela Propriedades.
4. Localize a propriedade Texto na janela Propriedades. Dependendo de como a lista
estiver classificada, talvez seja necessário rolar para baixo. Insira o valor Teste de
Matemática no valor Texto e selecione Enter.
Agora, seu formulário tem o texto "Teste de Matemática" na barra de título.
７ Observação
Você pode exibir as propriedades por categoria ou em ordem alfabética. Use

os botões na janela Propriedades para alternar para frente e para trás.
5. Altere o tamanho do formulário para 500 pixels de largura por 400 pixels de altura.
Você pode redimensionar o formulário arrastando suas bordas ou arrastando a

alça até que o tamanho correto apareça como o valor Tamanho na janela
Propriedades. A alça do identificador é um quadrado branco pequeno no canto
inferior direito do formulário. Você também pode redimensionar o formulário
alterando os valores da propriedade Tamanho.
6. Altere o valor da propriedade FormBorderStyle para Fixed3D e defina a

propriedade MaximizeBox para False.
Esses valores impedem que os participantes de teste redimensionem o formulário.
Criar a caixa tempo restante

O teste de matemática contém uma caixa no canto superior direito. Essa caixa mostra o
número de segundos que permanecem no teste. Essa seção mostra como usar um
rótulo dessa caixa. Você adicionará código para o temporizador de contagem regressiva
em um tutorial posterior nesta série.

Ctrl+Alt+X.
2. Selecione o controle Label na Caixa de Ferramentas e arraste-o para o formulário.
3. Na caixa Propriedades, defina as seguintes propriedades para o rótulo:
Defina o(Nome) como timeLabel.

Altere AutoSize para False de modo que você possa redimensionar a caixa.
Altere BorderStyle para FixedSingle para desenhar uma linha em torno da
caixa.
Defina o tamanho para 200, 30.
Selecione a propriedade Text e, em seguida, selecione a tecla Backspace para
limpar o valor Texto.
Selecione o sinal de adição (+) ao lado da propriedade Font e defina o
tamanho do como 15,75.
4. Mova o rótulo para o canto superior direito do formulário. Quando as linhas do

espaçador azul aparecerem, use-as para posicionar o controle no formulário.
5. Adicione outro controle Label da caixa de ferramentas e, em seguida, defina seu

tamanho da fonte para 15,75.
6. Defina a propriedade Text como Time Left.
7. Mova o rótulo de modo que ele alinhe à esquerda do rótulo timeLabel.
Adicionar controles aos problemas de adição

A primeira parte do teste é um problema de adição. Esta seção mostra como usar
rótulos para exibir esse problema.
1. Adicione um controle de rótulo a partir da Caixa de ferramentas ao formulário.
2. Na caixa Propriedades, defina as seguintes propriedades para o rótulo:
Defina o Texto como ? (ponto de interrogação).

Defina AutoSize como False.
Defina o Tamanho para 60, 50.
Defina o tamanho da fonte como 18.
Defina TextAlign como Middlecenter.
Defina Location como 50, 75 para posicionar o controle no formulário.
Defina (Name) como plusLeftLabel.
3. No formulário, selecione o rótulo plusLeftLabel que você criou. Copie o rótulo

selecionando Editar>Copiar ou Ctrl+C.
4. Cole o rótulo no formulário três vezes selecionando Editar>Colar ou Ctrl+V três

vezes.
5. Organize os três novos rótulos de modo que fiquem em uma linha à direita do
rótulo plusLeftLabel.
6. Defina a propriedade Text do segundo rótulo como + (sinal de mais).
7. Defina a propriedade (Name) do terceiro rótulo como plusRightLabel.
8. Defina a propriedade Text do quarto rótulo como = (sinal de igual).
9. Adicione um controle NumericUpDown a partir da Caixa de ferramentas ao

formulário. Você aprenderá mais sobre esse tipo de controle posteriormente.
10. Na caixa Propriedades, defina as seguintes propriedades para o controle

NumericUpDown:

Defina a largura como 100.
Defina o (Nome) como soma.
11. Alinhe o controle NumericUpDown com os controles Label para o problema de

adição.
Adicionar controles para subtração,

multiplicação e problemas de divisão
Em seguida, adicione rótulos ao formulário para os problemas matemáticos restantes.
1. Copie os quatro controles Label e o controle NumericUpDown que você criou para
o problema de adição. Cole-os no formulário.
2. Mova os novos controles para alinhar abaixo dos controles de adição.
3. Na caixa Propriedades, defina as seguintes propriedades dos novos controles:

Defina o (Name) do primeiro rótulo de ponto de interrogação como
minusLeftLabel.
Defina o Texto do segundo rótulo como - (sinal de subtração).
Defina o (Name) do segundo rótulo de ponto de interrogação como
minusRightLabel.
Defina o (Name) do controle NumericUpDown como diferença.
4. Copie os controles de adição e cole-os mais duas vezes no formulário.
5. Na terceira linha:

timesLeftLabel.
Defina o Texto do segundo rótulo como × (sinal de multiplicação). É possível
copiar o sinal de multiplicação deste tutorial e colá-lo no formulário.
timesRightLabel.
Defina o (Name) do controle NumericUpDown como produto.
6. Na quarta linha:

dividedLeftLabel.
Defina o Texto do segundo rótulo como ÷ (sinal de divisão). É possível copiar
o sinal de divisão deste tutorial e colá-lo no formulário.
dividedRightLabel.
Defina o (Name) do controle NumericUpDown como quociente.
Adicionar um botão Iniciar e definir a ordem
do índice de guias
Esta seção mostra como adicionar um botão iniciar. Você também especificará a ordem
de tabulação dos controles. Essa ordenação determina como o participante do teste
passa de um controle para o outro usando a tecla Tab.
1. Adicione um controle Button a partir da Caixa de ferramentas ao formulário.
2. Na caixa Propriedades, defina as seguintes propriedades do botão:
Defina o (Name) como startButton.

Defina Text como Iniciar o teste.
Defina AutoSize como True, o que faz com que o botão seja redimensionado
automaticamente para se ajustar ao texto.
Defina TabIndex como 0. Esse valor torna o botão Iniciar o primeiro controle
a receber o foco.
3. Centralize o botão próximo à parte inferior do formulário.

4. Na caixa Propriedades , defina a propriedade TabIndex de cada controle
NumericUpDown:
Defina TabIndex da soma do controle NumericUpDown como 1.

Defina TabIndex da diferença do controle NumericUpDown como 2.
Defina TabIndex do produto do controle NumericUpDown como 3.
Defina TabIndex do quociente do controle NumericUpDown como 4.
Os problemas matemáticos ainda não funcionam no teste. Mas você ainda pode
executar seu aplicativo para verificar se os valores tabIndex funcionam como esperado.
1. Use um dos seguintes métodos para salvar seu aplicativo:
Selecione Ctrl+Shift+S.
Na barra de menus, selecione Arquivo>Salvar tudo.
Na barra de ferramentas, selecione o botão Salvar tudo.
2. Use um dos seguintes métodos para executar seu aplicativo:
Selecione F5.
Na barra de menus, selecione Depurar>Iniciar depuração.
3. Selecione a tecla Tab algumas vezes para ver como o foco se move de um controle
para o outro.
Próximas etapas
Prossiga para o próximo tutorial para adicionar problemas matemáticos aleatórios e um
manipulador de eventos ao teste de matemática.
Parte 2 do tutorial: Adicionar problemas matemáticos a um aplicativo WinForms

Tutorial: Adicionar problemas
matemáticos a um aplicativo WinForms
Artigo • 18/03/2023
Os controles usam código C# ou Visual Basic. No segundo tutorial, você deixa o teste
desafiador adicionando código de problemas de matemática baseados em números
aleatórios. Você também cria um método chamado StartTheQuiz() para completar os
problemas.
＂ Escreva código para criar objetos Aleatórios a serem usados em problemas

matemáticos.
＂ Adicione um manipulador para o botão iniciar:
＂ Escreva o código para iniciar o teste.
Pré-requisitos
Este tutorial se baseia em um tutorial anterior, Criar um aplicativo WinForms de teste de
matemática. Se você ainda não concluiu esse tutorial, passe por ele primeiro.
Criar um problema de adição aleatório

1. Em seu projeto do Visual Studio, selecione Designer de Formulários do Windows.
2. Selecione o formulário Form1.
3. Na barra de menus, selecione exibir>Código. Form1.cs ou Form1.vb aparecerá,

dependendo da linguagem de programação que você estiver usando, para que
você possa exibir o código do formulário.
4. Crie um objeto de Random adicionando uma instrução de new próximo à parte

superior do código.
C#
C#
public partial class Form1 : Form

{
// Create a Random object called randomizer
// to generate random numbers.
Random randomizer = new Random();
） Importante

Você pode usar instruções new como esta para criar botões, rótulos, painéis,
OpenFileDialogs, ColorDialogs, SoundPlayers, Randoms e até mesmo formulários. Esses
itens são chamados de objetos.
Quando você executa o programa, o formulário é iniciado. O código por trás dele cria
um objeto Random e o nomeia como randomizador.
Seu teste precisa de variáveis para armazenar os números aleatórios que ele cria para
cada problema. Para usar variáveis corretamente, você deve declará-las, o que significa
listar seus nomes e tipos de data.
1. Adicione duas variáveis de inteiro ao formulário e nomeie-as addend1 e addend2.
７ Observação
Uma variável inteira é conhecida como um int em C# ou como Integer no

Visual Basic. Esse tipo de variável armazena um número positivo ou negativo
de -2147483648 a 2147483647 e pode armazenar apenas números inteiros,
não decimais.
Use uma sintaxe semelhante para adicionar uma variável inteira, como fez para
adicionar o objeto Random, desde que o código a seguir seja mostrado.
C#
C#

// These integer variables store the numbers

// for the addition problem.
int addend1;
int addend2;
1. Adicionar um método chamado StartTheQuiz() . Esse método usa o método Next()

do objeto Random para gerar números aleatórios para os rótulos. Por fim, o
StartTheQuiz() preencherá todos os problemas e iniciar o temporizador, por isso,
adicione essa informação ao comentário de resumo. A função deverá ser

semelhante ao seguinte código:
C#
C#
/// <summary>
/// Start the quiz by filling in all of the problems
/// and starting the timer.
/// </summary>
public void StartTheQuiz()
{
// Fill in the addition problem.
// Generate two random numbers to add.
// Store the values in the variables 'addend1' and 'addend2'.
addend1 = randomizer.Next(51);
// Convert the two randomly generated numbers

// into strings so that they can be displayed
// in the label controls.
plusLeftLabel.Text = addend1.ToString();
plusRightLabel.Text = addend2.ToString();
// 'sum' is the name of the NumericUpDown control.

// This step makes sure its value is zero before
// adding any values to it.
sum.Value = 0;
}
Quando você usa o método Next() com um objeto rRandom, como quando você
chama randomizer.Next(51) , você obtém um número aleatório que é menor que 51, ou
entre 0 e 50. Esse código chama randomizer.Next(51) para que os dois números
aleatórios adicionem uma resposta entre 0 e 100.
Confira de perto estas instruções.
C#
C#
Essas instruções definem propriedades Text de plusLeftLabel e plusRightLabel de modo

que elas exibam os dois números aleatórios. Os controles de rótulo exibem valores no
formato de texto e, na programação, as cadeias de caracteres mantêm o texto. Cada
método ToString() de inteiro converte o inteiro em texto que um rótulo pode exibir.
Criar problemas aleatórios de subtração,

multiplicação e divisão
A próxima etapa é declarar variáveis e fornecer valores aleatórios para os outros
problemas matemáticos.
1. Adicione variáveis de inteiro para os problemas matemáticos restantes ao

formulário, após as variáveis de problema de adição. O código deve se parecer
com o seguinte exemplo.
C#
C#
{

int addend1;
int addend2;

// for the subtraction problem.
int minuend;
int subtrahend;

// for the multiplication problem.
int multiplicand;
int multiplier;

// for the division problem.
int dividend;
int divisor;
1. Modifique o método StartTheQuiz() adicionando o código a seguir, começando

com o comentário "Preencher o problema de subtração".
C#
C#
/// <summary>
/// Start the quiz by filling in all of the problem
/// values and starting the timer.
/// </summary>
{

sum.Value = 0;
// Fill in the subtraction problem.

minuend = randomizer.Next(1, 101);
subtrahend = randomizer.Next(1, minuend);
minusLeftLabel.Text = minuend.ToString();
minusRightLabel.Text = subtrahend.ToString();
difference.Value = 0;
// Fill in the multiplication problem.

multiplicand = randomizer.Next(2, 11);
multiplier = randomizer.Next(2, 11);
timesLeftLabel.Text = multiplicand.ToString();
timesRightLabel.Text = multiplier.ToString();
product.Value = 0;
// Fill in the division problem.

divisor = randomizer.Next(2, 11);
int temporaryQuotient = randomizer.Next(2, 11);
dividend = divisor * temporaryQuotient;
dividedLeftLabel.Text = dividend.ToString();
dividedRightLabel.Text = divisor.ToString();
quotient.Value = 0;
Esse código usa o método Next() da classe Random de modo um pouco diferente de do
problema de adição. Quando você fornece dois valores do método de Next() , ele
escolhe um número aleatório maior ou igual ao primeiro valor e menor que o segundo.
Usando o método Next() com dois argumentos, você pode garantir que o problema de
subtração tenha uma resposta positiva, a resposta de multiplicação seja no máximo 100
e a resposta de divisão não seja uma fração.
Adicione um manipulador para o botão iniciar

Nesta seção, você adicionará código para iniciar o teste quando o botão Iniciar estiver
selecionado. O código executado em reação a um evento como uma seleção de botão é
chamado de manipulador de eventos.
1. No Designer de Formulários do Windows, clique duas vezes no botão Iniciar o

teste ou selecione-o e pressione Enter. O código do formulário é exibido e um
novo método é visível.
Essas ações adicionam um manipulador de eventos Click ao botão Iniciar. Quando
um participante do teste seleciona esse botão, o aplicativo executa o código que
você adicionará a esse novo método.
2. Adicione as duas instruções a seguir para que o manipulador de eventos inicie o

teste.
C#
C#
private void startButton_Click(object sender, EventArgs e)

{
StartTheQuiz();
startButton.Enabled = false;
}
A primeira instrução chama o novo método de StartTheQuiz() . A segunda instrução

define a propriedade Enabled do controle startButton para false de modo que a
pessoa realizando o teste não pode escolher o botão durante um teste.
1. Salve seu código.
2. Execute seu aplicativo e, em seguida, selecione Iniciar o teste. Problemas

matemáticos aleatórios aparecem, como mostra a captura de tela a seguir.
Próximas etapas
Avance para o próximo tutorial para adicionar um temporizador ao teste de matemática
e verificar as respostas dos usuários.
Parte 3 do tutorial: Adicionar um controle de temporizador a um aplicativo

WinForms de teste de matemática
Tutorial: Adicionar um temporizador a
um aplicativo WinForms de teste de
matemática
Artigo • 13/01/2024
quatro problemas matemáticos aleatórios que um participante tentará responder em
um tempo especificado.
O teste usa um controle de Temporizador. O código por trás desse controle controla o
tempo decorrido e verifica as respostas do participante.
Neste terceiro tutorial, você aprenderá a:
＂ Adicione um controle de Temporizador.

＂ Adicionar um manipulador de eventos para o temporizador.
＂ Escrever código para verificar as respostas do usuário, exibir mensagens e
preencher as respostas corretas.
Pré-requisitos
Este tutorial se baseia em tutoriais anteriores, começando com Criar um aplicativo
WinForms para um teste de matemática. Você precisa concluir esses tutoriais antes, caso
ainda não tenha feito isso.
Adicionar um temporizador de contagem

regressiva
Para acompanhar o tempo durante o teste, use um componente de temporizador. Você
também precisa de uma variável para armazenar o tempo restante.
1. Adicione uma variável de inteiro chamada timeLeft da mesma forma que você
declarou variáveis nos tutoriais anteriores. Coloque a declaração timeLeft logo
após as outras declarações. O código deve se parecer com o exemplo a seguir.
C#
{

int addend1;
int addend2;

// for the subtraction problem.
int minuend;
int subtrahend;

// for the multiplication problem.
int multiplicand;
int multiplier;

// for the division problem.
int dividend;
int divisor;
// This integer variable keeps track of the

// remaining time.
int timeLeft;
） Importante

2. No Designer de Formulários do Windows, mova um controle Timer da categoria
Componentes da Caixa de Ferramentas para seu formulário. O controle aparece
na área cinza na parte inferior da janela de design.
3. No formulário, selecione o ícone timer1 que você acabou de adicionar e defina sua
propriedade Intervalo como 1000. Como esse intervalo está em milissegundos, um
valor de 1000 faz com que o temporizador gere um evento Tick a cada segundo.
Verificar as respostas
Como o temporizador gera um evento Tick a cada segundo, faz sentido verificar o
tempo decorrido em um manipulador de eventos Tick. Também é prático verificar as
respostas nesse manipulador de eventos. Se o tempo tiver se esgotado ou se as
respostas estiverem corretas, o teste deverá terminar.
Antes de escrever esse manipulador de eventos, adicione um método chamado

CheckTheAnswer() para determinar se as respostas para os problemas matemáticos
estão corretas. Esse método deve estar alinhado com os outros métodos, como
StartTheQuiz() . O código deve se parecer com o exemplo a seguir.
C#
/// <summary>
/// Check the answers to see if the user got everything right.
/// </summary>
/// <returns>True if the answer's correct, false otherwise.</returns>
private bool CheckTheAnswer()
{
if ((addend1 + addend2 == sum.Value)
&& (minuend - subtrahend == difference.Value)
&& (multiplicand * multiplier == product.Value)
&& (dividend / divisor == quotient.Value))
return true;
else
return false;
}
Esse método determina as respostas para os problemas matemáticos e compara os

resultados com os valores nos controles NumericUpDown. Neste código:
A versão do Visual Basic usa a palavra-chave Function em vez da palavra-chave

comum Sub porque esse método retorna um valor.
Não é possível inserir facilmente o sinal de multiplicação (×) e o sinal de divisão
(÷) usando o teclado, de modo que o C# e o Visual Basic aceitam um asterisco (*)
para multiplicação e uma barra (/) para divisão.
No C#, && é o operador logical and . No Visual Basic, o operador equivalente é

AndAlso . Use o operador logical and para verificar se mais de uma condição é
verdadeira. Nesse caso, se todos os valores estiverem corretos, o método retornará

um valor de true . Caso contrário, o método retorna um valor de false .
A instrução if usa a propriedade Valor de um controle NumericUpDown para

acessar o valor atual do controle. Na próxima seção, você usará a mesma
propriedade para exibir a resposta correta em cada controle.
Adicionar um manipulador de eventos ao

temporizador
Agora que você tem uma maneira de verificar as respostas, pode escrever código para o
manipulador de eventos Tick. Esse código é executado a cada segundo, depois que o
temporizador gera um evento Tick. O manipulador de eventos verifica as respostas do
participante do teste chamando CheckTheAnswer() . Ele também verifica quanto tempo
passou no teste.
1. No formulário, clique duas vezes no controle de Temporizador ou selecione-o e

pressione Enter. Essas ações adicionam um manipulador de eventos Tick ao
temporizador. O editor de código aparece e exibe o método do manipulador Tick.
2. Adicione as seguintes instruções ao novo método do manipulador de eventos.
C#
private void timer1_Tick(object sender, EventArgs e)

{
if (CheckTheAnswer())
{
// If CheckTheAnswer() returns true, then the user
// got the answer right. Stop the timer
// and show a MessageBox.
timer1.Stop();
MessageBox.Show("You got all the answers right!",
"Congratulations!");
startButton.Enabled = true;
}
else if (timeLeft > 0)
{
// If CheckTheAnswer() returns false, keep counting
// down. Decrease the time left by one second and
// display the new time left by updating the
// Time Left label.
timeLeft = timeLeft - 1;
timeLabel.Text = timeLeft + " seconds";
}
else
{
// If the user ran out of time, stop the timer, show
// a MessageBox, and fill in the answers.
timer1.Stop();
timeLabel.Text = "Time's up!";
MessageBox.Show("You didn't finish in time.", "Sorry!");
sum.Value = addend1 + addend2;
difference.Value = minuend - subtrahend;
product.Value = multiplicand * multiplier;
quotient.Value = dividend / divisor;
startButton.Enabled = true;
}
}
A cada segundo do teste, esse método é executado. Primeiro, o código verifica o valor
que CheckTheAnswer() retorna.
Se todas as respostas estiverem corretas, esse valor será true e o teste terminará:
O temporizador para.
Uma mensagem de felicitação é exibida.
A propriedade Habilitado do controle startButton está definida como true
para que o participante do teste possa começar outro teste.
Se CheckTheAnswer() retornar false , o código verificará o valor de timeLeft:

Se essa variável for maior que 0, o temporizador subtrairá 1 de timeLeft. Ele
também atualizará a propriedade Texto do controle timeLabel para mostrar ao
participante do teste quantos segundos restam.
Se não restar mais tempo, o temporizador será interrompido e alterará o texto
de timeLabel para O tempo acabou!. Uma caixa de mensagem anuncia que o
teste acabou e as respostas são reveladas. O botão Iniciar fica disponível
novamente.
Iniciar o temporizador
Para iniciar o temporizador quando o teste for iniciado, adicione três linhas ao final do
método StartTheQuiz() , como mostra o exemplo a seguir.
C#
/// <summary>
/// Start the quiz by filling in all of the problem
/// values and starting the timer.
/// </summary>
{


sum.Value = 0;
// Fill in the subtraction problem.

minuend = randomizer.Next(1, 101);
subtrahend = randomizer.Next(1, minuend);
minusLeftLabel.Text = minuend.ToString();
minusRightLabel.Text = subtrahend.ToString();
difference.Value = 0;
// Fill in the multiplication problem.

multiplicand = randomizer.Next(2, 11);
multiplier = randomizer.Next(2, 11);
timesLeftLabel.Text = multiplicand.ToString();
timesRightLabel.Text = multiplier.ToString();
product.Value = 0;
// Fill in the division problem.

divisor = randomizer.Next(2, 11);
int temporaryQuotient = randomizer.Next(2, 11);
dividend = divisor * temporaryQuotient;
dividedLeftLabel.Text = dividend.ToString();
dividedRightLabel.Text = divisor.ToString();
quotient.Value = 0;
// Start the timer.

timeLeft = 30;
timeLabel.Text = "30 seconds";
timer1.Start();
}
Quando o teste for iniciado, o código definirá a variável timeLeft como 30 e a

propriedade Texto do controle timeLabel será definida como 30 segundos. O método
Start() de controle do Temporizador inicia a contagem regressiva.
1. Salve seu programa e o execute.
2. Selecione Iniciar o teste. O temporizador inicia a contagem regressiva. Quando o

tempo se esgota, o teste termina e a resposta aparece.
3. Inicie outro teste e forneça respostas corretas para os problemas matemáticos.

Quando você responde corretamente dentro do limite de tempo, uma caixa de
mensagem é aberta, o botão Iniciar fica disponível e o temporizador é
interrompido.
Próximas etapas
Prossiga para o próximo tutorial para saber como personalizar seu teste de matemática.
Tutorial parte 4: Personalizar um aplicativo WinForms de teste de matemática

Tutorial: Personalizar um aplicativo
WinForms para um teste de matemática
Artigo • 24/04/2023
Este tutorial mostra como aprimorar o teste limpando valores padrão e personalizando
a aparência dos controles.
Neste tutorial final, você aprenderá a:
＂ Adicionar manipuladores de eventos para limpar os valores de controle padrão

NumericUpDown.
＂ Personalizar o teste.
Pré-requisitos
Este tutorial se baseia em tutoriais anteriores, começando com Criar um aplicativo
WinForms para um teste de matemática. Você precisa concluir esses tutoriais antes, caso
ainda não tenha feito.
Adicionar manipuladores de eventos aos

controles NumericUpDown
O teste contém os controles NumericUpDown que os participantes do teste usam para
inserir números. Ao inserir uma resposta, você precisa primeiro selecionar o valor
padrão ou excluir esse valor manualmente. Adicionar um manipulador de eventos Enter
pode facilitar a inserção de respostas. Esse código seleciona e desmarca o valor atual
em cada controle NumericUpDown para que quem fizer o teste possa escolher e inserir
um valor diferente.
1. Selecione o primeiro controle NumericUpDown no formulário. Na caixa de diálogo

Propriedades, selecione o ícone Eventos na barra de ferramentas.
A guia Eventos na caixa de diálogo Propriedades exibe todos os eventos para os
quais você pode responder para o item que você selecionou no formulário. Nesse
caso, todos os eventos listados pertencem ao controle NumericUpDown.
2. Selecione o evento Enter, insira answer_Enter e selecione Enter.
O editor de código aparece exibindo o manipulador de eventos Enter que você

criou para o controle NumericUpDown de soma.
3. No método para o manipulador de eventos answer_Enter, adicione o código a

seguir:
C#
C#
private void answer_Enter(object sender, EventArgs e)

{
// Select the whole answer in the NumericUpDown control.
NumericUpDown answerBox = sender as NumericUpDown;
if (answerBox != null)
{
int lengthOfAnswer = answerBox.Value.ToString().Length;
answerBox.Select(0, lengthOfAnswer);
}
}
） Importante
Neste código:
A primeira linha declara o método. Inclui o parâmetro sender . Em C#, o parâmetro

é object sender . In Visual Basic, é sender As System.Object . Este parâmetro
refere-se ao objeto cujo evento é acionando, que é conhecido como o remetente.
Nesse caso, o objeto remetente é o controle NumericUpDown.
A primeira linha dentro do método converte o remetente de um objeto genérico
em um controle NumericUpDown. Essa linha também atribui o nome answerBox
ao controle NumericUpDown. Todos os controles NumericUpDown no formulário
usarão esse método, não apenas o controle do problema de adição.
A próxima linha verifica se answerBox foi convertido com êxito em um controle
NumericUpDown.
A primeira linha dentro da instrução if determina o comprimento da resposta
que está atualmente no controle NumericUpDown.
A segunda linha dentro da instrução if usa o comprimento da resposta para
selecionar o valor atual no controle.
Quando o participante do teste seleciona o controle, o Visual Studio aciona esse evento.
Esse código seleciona a resposta atual. Assim que o participante do teste começa a
inserir uma resposta diferente, a resposta atual é apagada e substituída pela nova.
1. No Designer de Formulários do Windows, selecione o controle NumericUpDown

do problema de adição novamente.
2. Na página Eventos da caixa de diálogo Propriedades, localize o evento Clique e

selecione answer_Enter no menu suspenso. Esse manipulador de eventos é aquele
que você acabou de adicionar.
3. No Designer de Formulários do Windows, selecione o controle NumericUpDown

do problema de subtração.
4. Na página Eventos da caixa de diálogo Propriedades, localize o evento Enter e
selecione answer_Enter no menu suspenso. Esse manipulador de eventos é aquele
que você acabou de adicionar. Repita esta etapa para o evento Clique.
5. Repita as duas etapas anteriores para os controles NumericUpDown de

multiplicação e divisão.
1. Salve seu programa e o execute.
2. Inicie um teste e selecione um controle NumericUpDown. O valor existente é

automaticamente selecionado e apagado quando você começa a inserir um valor
diferente.
Personalizar seus aplicativos

Nesta última parte do tutorial, você explorará algumas maneiras de personalizar o
questionário e expandir o que aprendeu.
Alterar a cor de um rótulo

Use a propriedade BackColor do controle timeLabel para tornar esse rótulo
vermelho quando restarem apenas mais cinco segundos em um teste.
C#
C#
timeLabel.BackColor = Color.Red;
Redefina a cor quando o teste acabar.
Reproduzir um som para a resposta correta

Dê ao comprador de teste uma dica executando um som quando a resposta correta for
inserida em um controle NumericUpDown. Para implementar essa funcionalidade, grave
um manipulador de eventos para o evento ValueChanged de cada controle. Esse tipo de
evento é acionado sempre que um participante do teste altera o valor do controle.
Próximas etapas
Parabéns! Você terminou esta série de tutoriais. Você concluiu essas tarefas de
Criou um projeto do Visual Studio que usa o Windows Forms

Adicionou rótulos, um botão e controles NumericUpDown
Adicionou um temporizador
Configurou manipuladores de eventos para seus controles
Gravou um código C# ou Visual Basic para manipular os eventos
Continue aprendendo com outras séries de tutoriais sobre como criar um jogo
correspondente.
Tutorial 3: Criar um jogo de correspondência

Tutorial: Criar um aplicativo de jogo da
memória no WinForms
Artigo • 20/03/2023
Nesta série de quatro tutoriais, você cria um jogo da memória em que o jogador
encontra pares de ícones ocultos.
Use esses tutoriais para saber mais sobre as tarefas a seguir no IDE (Ambiente de Design
Integrado) do Visual Studio.
Armazenar objetos, como ícones, em um objeto List<T>.

Usar um loop foreach no C# ou um loop For Each no Visual Basic para iterar
pelos itens em uma lista.
Acompanhar o estado de um formulário usando variáveis de referência.
Criar um manipulador de eventos para responder a eventos que você pode usar
com vários objetos.
Criar um temporizador que faça a contagem regressiva e dispare um evento logo
depois que ele for iniciado.
Quando terminar, você terá um jogo completo.

＂ Crie um projeto do Visual Studio que usa o Windows Forms.

＂ Adicione e formate um elemento de layout.
＂ Adicione e formate rótulos a serem exibidos.
Pré-requisitos
Criar seu projeto de jogo da memória no

Windows Forms
Ao criar um jogo da memória, a primeira etapa é criar um projeto de aplicativo do
Windows Forms.


de Trabalho na lista Todos os tipos de projeto.

７ Observação


necessário salvar o trabalho. Nesse caso, execute essa ação. Em seguida,
selecione Continuar para instalar a carga de trabalho.
5. Na janela Configurar seu novo projeto, dê ao projeto o nome MatchingGame, e,

em seguida, selecione Criar.
todos os projetos e arquivos necessários pelo seu aplicativo.
Neste ponto, o Visual Studio exibe um formulário vazio no Designer de Formulários do
Windows.
Criar um layout para seu jogo

Nesta seção, você criará a grade quatro por quatro do jogo.
1. Clique no formulário para selecionar o Designer de Formulários do Windows. A

guia lê Form1.cs [Design] para C# ou Form1.vb [Design] para Visual Basic. Na
janela Propriedades, defina as propriedades de formulário a seguir.
Altere a propriedade Texto de Form1 para Jogo da Memória. Esse texto

aparece na parte superior da janela do jogo.
Defina o tamanho do formulário. Você pode alterá-lo definindo a
propriedade Tamanho como 550, 550 ou arrastando o canto do formulário
até ver o tamanho correto na parte inferior do IDE do Visual Studio.
2. Selecione a guia Caixa de ferramentas no lado esquerdo do IDE. Se não for

exibida, selecione Exibir>Caixa de Ferramentas na barra de menus ou Ctrl+Alt+X.
3. Arraste um controle TableLayoutPanel da categoria Contêineres na caixa de

ferramentas ou clique duas vezes nele. Defina as seguintes propriedades para o
painel na janela Propriedades.
Defina a propriedade BackColor como CornflowerBlue. Para definir essa

propriedade, selecione a seta ao lado da propriedade BackColor. Na caixa de
diálogo BackColor, selecione Web. Nos nomes de cores disponíveis,
selecione CornflowerBlue.
７ Observação
As cores não estão em ordem alfabética e CornflowerBlue está quase no

fim da lista.
Defina a propriedade Dock como Fill na lista suspensa selecionando o botão

grande do meio. Essa opção estende a tabela para que ela cubra o formulário
inteiro.
Defina a propriedade CellBorderStyle como Baixo-relevo. Esse valor fornece

bordas visuais entre cada célula no tabuleiro.
Selecione o botão triangular no canto superior direito do TableLayoutPanel

para exibir o menu de tarefas. No menu de tarefas, selecione Adicionar linha
duas vezes para adicionar mais duas linhas. Em seguida, selecione Adicionar
coluna duas vezes para adicionar mais duas colunas.
No menu de tarefas, selecione Editar Linhas e Colunas para abrir a janela

Estilos de Coluna e Linha. Para cada coluna, selecione a opção Porcentagem
e defina a largura de cada coluna como 25 por cento.
Selecione Linhas na lista na parte superior da janela e, em seguida, defina a

altura de cada linha como 25%.
Quando você concluir, selecione OK para salvar as alterações.
Seu TableLayoutPanel agora é uma grade quatro por quatro com 16 células quadradas
de tamanho igual. Essas linhas e colunas estão onde os ícones aparecerão mais tarde.
Adicionar e formatar rótulos a serem exibidos

Nesta seção, você criará e formatará rótulos a serem exibidos durante o jogo.
1. Certifique-se de que TableLayoutPanel esteja selecionado no editor de formulários.

Você deve ver tableLayoutPanel1 na parte superior da janela Propriedades. Se não
estiver selecionado, selecione o TableLayoutPanel no formulário ou selecione-o na
lista na parte superior da janela Propriedades.
2. Abra a caixa de ferramentas, como antes, e abra a categoria Controles comuns.

Adicione um controle Label à célula superior esquerda do TableLayoutPanel. O
controle Label agora está selecionado no IDE. Defina as propriedades a seguir para
ele.
Defina a propriedade BackColor do rótulo como CornflowerBlue.

Defina a propriedade AutoSize para False.
Defina a propriedade Encaixar como Preenchimento.
Defina a propriedade TextAlign como MiddleCenter escolhendo o botão
suspenso próximo à propriedade e selecionando o botão do meio. Esse valor
garante que o ícone apareça no meio da célula.
Selecione a propriedade Fonte. O botão reticências (...) aparece. Selecione as
reticências e defina o valor de Fonte como Webdings, o Estilo da Fonte
como Negrito e o Tamanho como 48.
Defina a propriedade Texto do rótulo como a letra c.
A célula superior esquerda no TableLayoutPanel agora contém uma caixa preta

centrada em um plano de fundo azul.
７ Observação
Webdings é uma fonte de ícones que acompanha o sistema operacional

Windows. No jogo da memória, o jogador faz a correspondência entre os
pares de ícones. Essa fonte exibe os ícones a serem correspondidos.
Em vez de c, tente letras diferentes na propriedade Text. Um ponto de

exclamação é uma aranha, um N maiúsculo é um olho e uma vírgula é uma
pimenta.
3. Selecione o controle de rótulo e copie-o ao lado da célula no TableLayoutPanel.

Selecione as teclas Ctrl+C ou, na barra de menus, Editar>Copiar. Em seguida, cole
usando Ctrl+V ou Editar>Colar.
Uma cópia do primeiro rótulo aparece na segunda célula de TableLayoutPanel.

Cole-o novamente e outro rótulo aparecerá na terceira célula. Continue colando
controles Label até que todas as células sejam preenchidas.
Esta etapa conclui o layout do formulário.
Próximas etapas
Vá para o próximo tutorial para saber como atribuir um ícone aleatório a cada rótulo e
adicionar manipuladores de eventos aos rótulos.
Adicionar ícones ao Jogo da Memória

Tutorial: Adicionar ícones ao aplicativo
WinForms do jogo correspondente
Artigo • 27/03/2023
No jogo correspondente, um jogador seleciona um quadrado para ver um ícone e, em

seguida, escolhe outro quadrado. Se os ícones corresponderem, eles permanecerão
visíveis. Caso contrário, o jogo oculta os dois ícones. Neste tutorial, você atribui ícones a
rótulos aleatoriamente. Defina-os como ocultos e, em seguida, exibidos quando
selecionados.
＂ Adicione um objeto aleatório e uma lista de ícones.

＂ Atribua um ícone aleatório a cada rótulo.
＂ Adicione manipuladores de eventos que mostram ícones aos rótulos.
Pré-requisitos
Este tutorial se baseia no tutorial anterior, Criar um aplicativo de jogo correspondente.
Se você ainda não fez esse tutorial, passe por ele primeiro.
Adicionar um objeto aleatório e uma lista de

ícones
Nesta etapa, você cria um conjunto de símbolos correspondentes para o jogo. Cada
símbolo é adicionado a duas células aleatórias no TableLayoutPanel do formulário.
Você usa instruções new para criar dois objetos. O primeiro é um objeto Random que
escolhe aleatoriamente células no TableLayoutPanel. O segundo objeto é um objeto
List<T>. Ele armazena os símbolos escolhidos aleatoriamente.
1. Abra o Visual Studio. Seu projeto MatchingGame aparece em Abrir recente.
2. Selecione Form1.cs se você estiver usando C# ou Form1.vb se estiver usando o

Visual Basic. Em seguida, selecione Exibir>Código. Como alternativa, selecione a
tecla F7 ou clique duas vezes em Form1. O IDE do Visual Studio exibe o módulo de
código para Form1.
3. No código existente, adicione o código a seguir.
C#
C#

{
// Use this Random object to choose random icons for the
squares
Random random = new Random();
// Each of these letters is an interesting icon

// in the Webdings font,
// and each icon appears twice in this list
List<string> icons = new List<string>()
{
"!", "!", "N", "N", ",", ",", "k", "k",
"b", "b", "v", "v", "w", "w", "z", "z"
};
） Importante

Se você estiver usando o C#, certifique-se de colocar o código após a chave da abertura
e logo após a declaração de classe ( public partial class Form1 : Form ). Se estiver
usando o Visual Basic, coloque o código logo depois da declaração de classe ( Public
Class Form1 ).
Você pode usar objetos de lista para acompanhar diferentes tipos de itens. Uma lista
pode manter números, valores verdadeiro/falso, texto ou outros objetos. No jogo
correspondente, o objeto de lista tem 16 cadeias de caracteres, uma para cada célula no
painel TableLayoutPanel. Cada cadeia de caracteres é uma única letra que corresponde
aos ícones nos rótulos. Esses caracteres aparecem na fonte Webdings como um ônibus,
uma bicicleta e outros.
７ Observação
As listas podem ser reduzidas e aumentadas, conforme a necessidade, que é

importante nesse programa.
Para saber mais sobre listas, confira List<T>. Para ver um exemplo em C#, confira Um
exemplo de lista básica. Para ver um exemplo no Visual Basic, confira Usar uma coleção
simples.
Atribuir um ícone aleatório a cada rótulo

Cada vez que você executa o programa, ele atribui os ícones aleatoriamente aos
controles Rótulo em seu formulário usando um método AssignIconsToSquares() . Esse
código usa a palavra-chave foreach em C# ou For Each no Visual Basic.
1. Adicione o método AssignIconsToSquares() .
C#
C#
/// <summary>
/// Assign each icon from the list of icons to a random square
/// </summary>
private void AssignIconsToSquares()
{
// The TableLayoutPanel has 16 labels,
// and the icon list has 16 icons,
// so an icon is pulled at random from the list
// and added to each label
foreach (Control control in tableLayoutPanel1.Controls)
{
Label iconLabel = control as Label;
if (iconLabel != null)
{
int randomNumber = random.Next(icons.Count);
iconLabel.Text = icons[randomNumber];
// iconLabel.ForeColor = iconLabel.BackColor;
icons.RemoveAt(randomNumber);
}
}
}
Você pode inserir esse código logo abaixo do código adicionado na seção anterior.
７ Observação
Uma das linhas é comentada de propósito. Adicione-a posteriormente neste

procedimento.
O método AssignIconsToSquares() itera por meio de cada controle de rótulo no

TableLayoutPanel. Ele executa as mesmas instruções para cada uma delas. As instruções
extraem um ícone aleatório da lista.
A primeira linha converte a variável control em um rótulo denominado iconLabel.

A segunda linha é uma instrução if que verifica se a conversão funcionou. Se a
conversão realmente funcionar, as instruções na instrução if serão executadas.
A primeira linha na instrução if cria uma variável denominada randomNumber
que contém um número aleatório que corresponde a um dos itens na lista de
ícones. Ela usa o método Next() do objeto Random. O método Next retorna o
número aleatório. Essa linha também usa a propriedade Count da lista icons para
determinar o intervalo do qual escolher o número aleatório.
A próxima linha atribui um dos itens da lista de ícones à propriedade Text do
rótulo.
A linha seguinte oculta os ícones. A linha é comentada aqui para que você possa
verificar o restante do código antes de continuar.
A última linha na instrução if remove o ícone que foi adicionado ao formulário da
lista.
1. Adicione uma chamada ao método AssignIconsToSquares() ao construtor Form1.

Esse método preenche o quadro de jogos com ícones. Construtores são chamados
quando você cria um objeto.
C#
public Form1()
{
InitializeComponent();
AssignIconsToSquares();
}
Para o Visual Basic, adicione a chamada de método AssignIconsToSquares() ao

método Form1_Load .
VB
Private Sub Form1_Load(sender As Object, e As EventArgs) Handles

MyBase.Load
AssignIconsToSquares()
End Sub
Para obter mais informações, confira Construtores (guia de programação em C#)

ou Usar construtores e destruidores.
2. Salve seu programa e o execute. Ele deve mostrar um formulário com ícones
aleatórios atribuídos a cada rótulo.
 Dica
Se os ícones de Webdings não forem exibidos corretamente no formulário,

defina a propriedade UseCompatibleTextRendering de rótulos no formulário
para True.
3. Feche seu programa e, em seguida, execute-o novamente. Ícones diferentes são

atribuídos a cada rótulo.
Os ícones estão visíveis agora porque você não os ocultou. Para ocultá-los do
jogador, você pode definir a propriedade ForeColor de cada rótulo para a mesma
cor de sua propriedade BackColor.
4. Interrompa o programa. Remova as marcas de comentário da linha de código

comentada dentro do loop.
C#
C#
iconLabel.ForeColor = iconLabel.BackColor;
Se você executar o programa novamente, os ícones parecem ter desaparecido. Somente

uma tela de fundo azul é exibida. Os ícones são atribuídos aleatoriamente e continuam
lá.
Adicionar manipuladores de eventos a rótulos
Neste jogo correspondente, um jogador revela um ícone oculto e, em seguida, um
segundo. Se os ícones corresponderem, eles permanecerão visíveis. Caso contrário,
ambos os ícones serão ocultados novamente.
Para que o jogo funcione dessa forma, adicione um manipulador de eventos Click que
altera a cor do rótulo escolhido para corresponder à tela de fundo.
1. Abra o formulário no Designer de Formulários do Windows. Selecione Form1.cs

ou Form1.vb e, em seguida, selecione Exibir>Designer.
2. Escolha o primeiro controle de rótulo para selecioná-lo e clique duas vezes nele
para adicionar um manipulador de eventos Click chamado label1 _Click() ao
código.
3. Em seguida, mantenha pressionada a tecla Ctrl enquanto seleciona cada um dos

outros rótulos. Verifique se cada um dos rótulos foi selecionado.
4. Na janela Propriedades, selecione o botão Eventos, que é um bolt de clareamento.

Para o evento Clicar, selecione label1_Click na caixa.
5. Pressione a tecla Enter. O IDE adiciona um manipulador de eventos Click

chamado label1 _Click() ao código. Como você selecionou todos os rótulos, o
manipulador é conectado a cada um deles.
6. Preencha o restante do código.
C#
C#
/// <summary>
/// Every label's Click event is handled by this event handler
/// </summary>
/// <param name="sender">The label that was clicked</param>
/// <param name="e"></param>
private void label1_Click(object sender, EventArgs e)
{
Label clickedLabel = sender as Label;
if (clickedLabel != null)
{
// If the clicked label is black, the player clicked
// an icon that's already been revealed --
// ignore the click
if (clickedLabel.ForeColor == Color.Black)
return;
clickedLabel.ForeColor = Color.Black;
}
}
７ Observação
Se você copiar e colar o bloco de código label1_Click() em vez de inserir o

código manualmente, não se esqueça de substituir o código label1_Click()
existente. Caso contrário, você terá um bloco de código duplicado.
Selecione Depurar>Iniciar Depuração para executar seu programa. Você deverá ver um
formulário vazio com um plano de fundo azul. Escolha qualquer uma das células no
formulário. Um dos ícones deve ficar visível. Continue escolhendo diferentes locais no
formulário. À medida que você escolhe os ícones, eles devem aparecer.
Próximas etapas
Avance para o próximo tutorial para saber como alterar rótulos usando um
temporizador.
Usar um temporizador no Jogo Correspondente

Tutorial: Adicionar variáveis de
referência e um controle de
temporizador ao aplicativo WinForms
do jogo da memória
Artigo • 16/03/2023
O programa Jogo da Memória precisa rastrear quais controles de rótulo o jogador

escolhe. Depois que um jogador escolhe o primeiro rótulo, o programa deve mostrar o
ícone. Depois que o segundo rótulo é escolhido, o programa deve exibir ambos os
ícones por um breve momento. Em seguida, oculta os dois ícones.
Seu programa controla qual rótulo você escolheu em primeiro e segundo lugar usando
variáveis de referência. Um temporizador oculta os ícones e controla por quanto tempo
mostrar os ícones
＂ Adicionar referências de rótulo.

＂ Adicionar um temporizador.
Pré-requisitos
Este tutorial se baseia em tutoriais anteriores, Criar um aplicativo de jogo da memória e
Adicionar ícones ao seu jogo da memória. Conclua esses tutoriais primeiro.
Adicionar referências de rótulo

Nesta seção, você adicionará duas variáveis de referência ao código. Elas controlam ou
referenciam objetos Rótulo.
1. Adicione referências de rótulo ao seu formulário usando o código a seguir.
C#
C#
{
// firstClicked points to the first Label control
// that the player clicks, but it will be null
// if the player hasn't clicked a label yet
Label firstClicked = null;
// secondClicked points to the second Label control

// that the player clicks
Label secondClicked = null;
） Importante

Essas instruções não fazem com que os controles de rótulo apareçam no formulário,
pois a palavra-chave new não existe. Quando o programa é iniciado, firstClicked e
secondClicked são definidos como null para o C# ou Nothing para o Visual Basic.
2. Modifique o manipulador de eventos Click para usar a nova variável de referência

firstClicked . Remova a última instrução no método do manipulador de eventos
label1_Click() ( clickedLabel.ForeColor = Color.Black; ) e a substitua pela

instrução if a seguir.
C#
C#
/// <summary>
/// </summary>
{
{
// ignore the click
return;
// If firstClicked is null, this is the first icon

// in the pair that the player clicked,
// so set firstClicked to the label that the player
// clicked, change its color to black, and return
if (firstClicked == null)
{
firstClicked = clickedLabel;
firstClicked.ForeColor = Color.Black;
return;
}
}
}
3. Salve e execute seu programa. Escolha um dos controles de rótulo e seu ícone é
exibido. Escolha o próximo controle de rótulo e observe que nada acontece.
Somente o primeiro ícone escolhido é exibido. Os outros ícones estão invisíveis.
O programa já está rastreando o primeiro rótulo escolhido pelo jogador. A referência

firstClicked não é null no C# nem Nothing no Visual Basic. Quando a instrução if
detecta que firstClicked não é igual a null nem Nothing , ela executa as instruções.
Adicionar um temporizador
O aplicativo de jogo da memória usa um controle Timer. Um temporizador aguarda e,
em seguida, dispara um evento, conhecido como um tique. Um temporizador pode
iniciar uma ação ou repetir uma ação regularmente.
Em seu programa, o temporizador permite que um jogador escolha dois ícones. Se os

ícones não corresponderem, ele ocultará os dois ícones novamente após um curto
período de tempo.
1. Selecione a guia Caixa de Ferramentas, na categoria Componentes, clique duas

vezes ou arraste o componente Temporizador para o formulário. O ícone do
temporizador, chamado timer1, aparece em um espaço abaixo do formulário.
2. Escolha o ícone Timer1 para selecionar o temporizador. Na janela Propriedades,
selecione o botão Propriedades para exibir as propriedades.
3. Defina a propriedade Intervalo como 750, que é igual a 750 milissegundos.
A propriedade Intervalo informa ao temporizador quanto tempo ele deve

aguardar entre os tiques, momento em que dispara o evento Tick. O programa
chamará o método Start() para iniciar o temporizador depois que o jogador
escolher o segundo rótulo.
4. Escolha o ícone de controle do temporizador e pressione Enter ou clique duas

vezes no temporizador. O IDE adiciona um manipulador de eventos Tick vazio.
Substitua o código pelo código seguinte.
C#
C#
/// <summary>
/// This timer is started when the player clicks
/// two icons that don't match,
/// so it counts three quarters of a second
/// and then turns itself off and hides both icons
/// </summary>
/// <param name="sender"></param>
private void timer1_Tick(object sender, EventArgs e)
{
// Stop the timer
timer1.Stop();
// Hide both icons

firstClicked.ForeColor = firstClicked.BackColor;
secondClicked.ForeColor = secondClicked.BackColor;
// Reset firstClicked and secondClicked

// so the next time a label is
// clicked, the program knows it's the first click
firstClicked = null;
secondClicked = null;
}
O manipulador de eventos de Tick realiza três tarefas:
Chamando o método Stop(), ele verifica se o temporizador não está em execução.

Ele usa duas variáveis de referência, firstClicked e secondClicked , para tornar
invisíveis novamente os ícones dos dois rótulos que jogador escolheu.
Ele redefine as variáveis de referência firstClicked e secondClicked como null
no C# e Nothing no Visual Basic.
5. Vá para o editor de código e adicione o código no início e no fim do método do

manipulador de eventos label1_Click() . Esse código verificará se o temporizador
está habilitado, definirá a variável de referência secondClicked e iniciará o
temporizador. O método do manipulador de eventos label1_Click() agora tem a
seguinte aparência:
C#
C#
/// <summary>
/// </summary>
{
// The timer is only on after two non-matching
// icons have been shown to the player,
// so ignore any clicks if the timer is running
if (timer1.Enabled == true)
return;
{
// ignore the click
return;
// If firstClicked is null, this is the first icon
// in the pair that the player clicked,
// so set firstClicked to the label that the player
// clicked, change its color to black, and return
if (firstClicked == null)
{
firstClicked = clickedLabel;
firstClicked.ForeColor = Color.Black;
return;
}
// If the player gets this far, the timer isn't

// running and firstClicked isn't null,
// so this must be the second icon the player clicked
// Set its color to black
secondClicked = clickedLabel;
secondClicked.ForeColor = Color.Black;
// If the player gets this far, the player

// clicked two different icons, so start the
// timer (which will wait three quarters of
// a second, and then hide the icons)
timer1.Start();
}
}
O código no início do método verifica se o temporizador foi iniciado verificando o

valor da propriedade Habilitado. Se o jogador escolher o primeiro e o segundo
controles de Rótulo e o temporizador for iniciado, a escolha de um terceiro rótulo
não terá nenhum efeito.
O código no fim do método define a variável de referência secondClicked para
rastrear o segundo controle de Rótulo. Em seguida, ele define a cor do ícone do
rótulo como preta para torná-la visível. Em seguida, ele inicia o temporizador no
modo de um único disparo, de modo que ele aguarda 750 milissegundos e dispara
um único tique. O manipulador de eventos do Tick do temporizador oculta os dois
ícones e redefine as variáveis de referência firstClicked e secondClicked . O
formulário está pronto para o jogador escolher outro par de ícones.
７ Observação
Se você copiar e colar o bloco de código label1_Click() em vez de inserir o

código manualmente, não se esqueça de substituir o código label1_Click()
existente. Caso contrário, você terá um bloco de código duplicado.
6. Salve e execute seu programa. Selecione um quadrado e o ícone ficará visível.
Escolha outro quadrado. O ícone aparece rapidamente e, em seguida, ambos
desaparecem.
Agora seu programa rastreia o primeiro e o segundo ícones que você escolhe. Ele usa o
temporizador para pausar antes de fazer os ícones desaparecerem.
Próximas etapas
Avance para o próximo tutorial para saber como concluir o Jogo da Memória.
Mostrar mensagem de parabéns no Jogo da Memória

Tutorial: Exibir uma mensagem no
aplicativo WinForms do jogo de
correspondência
Artigo • 27/03/2023
Neste tutorial, você revisará seu Jogo de Correspondência para manter os pares
correspondentes visíveis e exibir uma mensagem de parabéns quando um jogador
ganhar.
Neste tutorial, você aprenderá como:
＂ Manter os pares visíveis.

＂ Verificar se um jogador ganhou.
＂ Experimentar outros recursos.
Pré-requisitos
Este tutorial se baseia nestes tutoriais anteriores:
1. Criar um aplicativo de jogo da memória

2. Adicionar ícones ao seu jogo da memória
3. Adicionar um temporizador no seu jogo da memória
Manter os pares visíveis

Quando um jogador corresponde um par, o jogo deve ser redefinido para que ele não
acompanhe mais os rótulos que usam as variáveis de referência firstClicked e
secondClicked . Ele não deve redefinir as cores para os dois rótulos que foram
correspondidos. Esses rótulos continuam a ser exibidos.
1. Adicione a instrução if a seguir ao método do manipulador de eventos

label_Click() . Coloque-o perto do final do código logo acima da instrução em
que você inicia o temporizador.

C#
C#

// If the player clicked two matching icons, keep them

// black and reset firstClicked and secondClicked
// so the player can click another icon
if (firstClicked.Text == secondClicked.Text)
{
return;
}
// If the player gets this far, the player

// clicked two different icons, so start the
// timer (which will wait three quarters of
// a second, and then hide the icons)
timer1.Start();
}
}
） Importante

A instrução if verifica se o ícone no primeiro rótulo que o jogador escolhe é igual ao

ícone no segundo rótulo. Se os ícones forem iguais, o programa executará suas três
instruções. As duas primeiras instruções redefinem as variáveis de referência
firstClicked e secondClicked . Eles não acompanham mais nenhum dos rótulos. A
terceira instrução é uma instrução return , que ignora o restante das instruções no
método sem executá-las.
2. Execute o programa e, em seguida, comece a escolher os quadrados no

formulário.
Se você escolher um par que não corresponda, o evento Tick do temporizador será
disparado. Ambos os ícones desaparecem.
Se você escolher um par correspondente, a nova instrução if será executada. A

instrução return faz com que o método ignore o código que inicia o temporizador. Os
ícones permanecem visíveis.
Verificar se um jogador ganhou

Você criou um jogo divertido. Depois que um jogador ganhar, o jogo deverá terminar.
Esta seção adiciona um método para verificar se o jogador ganhou.
1. Adicione um método CheckForWinner() à parte inferior do código, abaixo do
manipulador de eventos timer1_Tick() .
C#
C#
/// <summary>
/// Check every icon to see if it is matched, by
/// comparing its foreground color to its background color.
/// If all of the icons are matched, the player wins
/// </summary>
private void CheckForWinner()
{
// Go through all of the labels in the TableLayoutPanel,
// checking each one to see if its icon is matched
foreach (Control control in tableLayoutPanel1.Controls)
{
Label iconLabel = control as Label;
if (iconLabel != null)
{
if (iconLabel.ForeColor == iconLabel.BackColor)
return;
}
}
// If the loop didn’t return, it didn't find

// any unmatched icons
// That means the user won. Show a message and close the form
MessageBox.Show("You matched all the icons!", "Congratulations");
Close();
}
O método usa outro loop foreach no C# ou o loop For Each no Visual Basic para
percorrer cada rótulo no TableLayoutPanel. Ele verifica a cor do ícone de cada rótulo
para verificar se ele corresponde à tela de fundo. Se as cores forem iguais, o ícone
permanecerá invisível e o jogador não combinou todos os ícones restantes.
Nesse caso, o programa usa uma instrução return para ignorar o restante do método.
Se o loop passar por todos os rótulos sem executar a instrução return , isso significa
que todos os ícones no formulário foram combinados. O programa mostra uma
MessageBox para parabenizar o jogador ganhador e, em seguida, chama o método
Close() para encerrar o jogo.
2. Em seguida, o manipulador de eventos Click do rótulo chama o novo método

CheckForWinner() .
C#
C#

// Check to see if the player won

CheckForWinner();
// If the player clicked two matching icons, keep them

// black and reset firstClicked and secondClicked
// so the player can click another icon
if (firstClicked.Text == secondClicked.Text)
{
return;
}
Verifique se seu programa busca um ganhador imediatamente depois que ele mostra o
segundo ícone que o jogador escolhe. Procure a linha onde você define a cor do
segundo ícone escolhido e chame o método CheckForWinner() logo depois dessa linha.
3. Salve e execute o programa. Jogue o jogo e combine todos os ícones. Quando

você ganha, o programa exibe uma mensagem de parabéns.
Depois de selecionar OK, o Jogo de Correspondência é fechado.
Experimentar outros recursos

Seu Jogo de Correspondência está completo. Você pode adicionar mais recursos para
tornar este jogo mais desafiador e interessante. Aqui estão algumas opções.
Substitua os ícones e as cores pelos de sua preferência.
Tente observar a propriedade ForeColor do rótulo.
Adicione um temporizador de jogo que controla em quanto tempo o jogador

ganha uma partida.
Você pode adicionar um rótulo para exibir o tempo decorrido no formulário.

Coloque-o acima de TableLayoutPanel. Adicione outro temporizador ao formulário
para acompanhar a hora. Use código para iniciar o temporizador quando o
jogador começar o jogo e para interromper o temporizador depois que os dois
últimos ícones forem encontrados.
Adicione um som para quando o jogador encontrar um par, outro som para
quando o jogador selecionar dois ícones que são diferentes e um terceiro som
para quando o programa ocultar os ícones novamente.
Para reproduzir sons, você pode usar o namespace System.Media. Para obter mais
informações, confira Reproduzir sons no aplicativo Windows Forms (C#) ou
Como reproduzir áudio no Visual Basic .
Torne o jogo mais difícil aumentando o tamanho do tabuleiro.
Você precisará fazer mais do que apenas adicionar linhas e colunas ao

TableLayoutPanel. Você também precisa considerar o número de ícones criados.
Torne o jogo mais desafiador ocultando o primeiro ícone se o jogador demorar

muito para responder.
Próximas etapas
Parabéns! Você concluiu esta série de tutoriais. Você concluiu estas tarefas de
Armazenou objetos, como ícones, em uma lista

Usou um loop no C# ou no Visual Basic para iterar por meio de uma lista
Manteve controle de estado usando variáveis de referência
Criou um manipulador de eventos para responder a eventos para vários objetos
Adicionou um temporizador que realiza uma contagem regressiva e dispara um
evento
Avance para este artigo para um aprofundamento no Designer de Formulários do

Windows.
Tutorial: introdução ao Designer de Formulários do Windows

Como executar um programa em C# no
Visual Studio
Artigo • 08/05/2023
A maneira de executar um programa depende de onde você começa, do tipo de

programa e de você desejar executar no depurador. No caso mais simples, para
compilar e executar um projeto aberto no Visual Studio:
Pressione F5, escolha Depurar>Iniciar com depuração no menu do Visual Studio

ou selecione a seta verde Iniciar e o nome do projeto na barra de ferramentas do
Visual Studio.
Ou, para executar sem depurar, pressione Ctrl+F5 ou escolha Depurar>Iniciar sem
depuração no menu do Visual Studio.
Iniciar em um projeto
Você pode executar um projeto em C# ou um arquivo .csproj quando ele é um
programa executável. Se o projeto contiver um arquivo C# com um método Main e a
saída dele for um arquivo executável ou .exe, ele provavelmente será executado se for
compilado com êxito. As versões mais recentes do C# não exigem um método Main ; em
vez disso, as execuções de programas começam com instruções de nível superior.
Consulte Programas sem métodos Main.
1. Se o código do programa já estiver em um projeto do Visual Studio, abra o

projeto. Para fazer isso, você pode clicar duas vezes ou tocar no arquivo .csproj no
Explorador de Arquivos do Windows ou escolher Abrir um projeto no Visual
Studio, procurar o arquivo .csproj e selecioná-lo.
2. Após o projeto ser carregado no Visual Studio, se a solução do Visual Studio tiver
mais de um projeto, defina o projeto com o método Main como o projeto de
inicialização. Para definir o projeto de inicialização, clique com o botão direito do
mouse no nome ou no nó do projeto no Gerenciador de Soluções e escolha
Definir como projeto de inicialização no menu de contexto.
3. Para executar o programa, pressione Ctrl+F5, selecione Depurar>Iniciar sem
depuração no menu superior ou selecione o botão verde Iniciar.
O Visual Studio tenta compilar e executar o projeto. Na parte inferior da tela do
Visual Studio, a saída do build aparece na janela Saída e os erros de build
aparecem na janela Lista de Erros.
Se o build for bem-sucedido, o aplicativo será executado conforme apropriado

para o tipo de projeto. Aplicativos de console são executados em uma janela de
terminal, aplicativos da área de trabalho do Windows são iniciados em uma nova
janela da área de trabalho e aplicativos Web são executados em um navegador
hospedado pelo IIS Express.
Iniciar no código
Se você iniciar em uma listagem de código, um arquivo de código ou um pequeno
número de arquivos, verifique primeiro se o código é um programa executável de uma
fonte confiável. Qualquer aplicativo com um método Main provavelmente é um
programa executável, mas com a versão atual do C#, programas sem métodos Main
com instruções de nível superior também podem ser executados. Você pode usar o
modelo Aplicativo de Console para criar um projeto para trabalhar com o aplicativo no
Visual Studio.
Listagem de código para um só arquivo

1. Inicie o Visual Studio e abra um projeto de Aplicativo de Console em C# vazio.
2. Substitua todo o código no arquivo .cs do projeto pelo conteúdo da listagem de
código ou do arquivo.
3. Renomeie o arquivo .cs do projeto para que corresponda ao nome do arquivo de
código.
Várias listagens de código ou arquivos em disco

1. Inicie o Visual Studio e crie um projeto do tipo apropriado. Use o Aplicativo de
Console em C# se não tiver certeza.
2. No novo projeto, substitua todo o código no arquivo de código do projeto pelo
conteúdo da sua primeira listagem de código ou arquivo.
3. Renomeie o arquivo de código do projeto para que corresponda ao nome do
arquivo de código.
4. Para cada arquivo de código restante:
a. Clique com o botão direito do mouse no nó do projeto no Gerenciador de
Soluções e escolha Adicionar>Item Existente ou selecione o projeto e
pressione Shift+Alt+A.
b. Navegue até e selecione o arquivo de código para importá-lo para o projeto.
Vários arquivos em uma pasta

Se você tem uma pasta com muitos arquivos, verifique se há um arquivo de solução ou
projeto. Os programas que o Visual Studio cria têm arquivos de projeto e solução. No
Explorador de Arquivos do Windows, procure arquivos com a extensão .csproj ou .sln.
Clique duas vezes no arquivo .csproj para abri-lo no Visual Studio. Consulte Iniciar em
uma solução ou projeto do Visual Studio.
Se o código for de outro ambiente de desenvolvimento, não haverá nenhum arquivo de

projeto. Abra a pasta escolhendo Abrir>Pasta no Visual Studio. Confira Desenvolver
código sem projetos nem soluções.
Iniciar em um repositório do GitHub ou Azure

DevOps
Se o código que você deseja executar estiver em um repositório do GitHub ou Azure
DevOps, você poderá usar o Visual Studio para abrir o projeto diretamente no
repositório. Confira Abrir um projeto em um repositório.
Execute o programa
Para começar a compilar o programa, pressione o botão verde Iniciar na barra de
ferramentas do Visual Studio ou pressione F5 ou Ctrl+F5. Usar o botão Iniciar ou F5
executa o programa no depurador.
O Visual Studio tenta compilar e executar o código no projeto. Se um build não for
bem-sucedido, consulte as seções a seguir para ver algumas ideias de como fazer com
que o projeto seja compilado com êxito.
Solução de problemas
O código pode ter erros. Ou o código pode estar correto, mas talvez dependa de
assemblies ou pacotes NuGet ausentes, ou tenha como destino uma versão diferente do
.NET. Nesses casos, talvez você consiga corrigir o build facilmente.
Adicionar referências
Para compilar corretamente, o código precisa estar correto e ter as referências certas a
bibliotecas ou outras dependências. Sublinhados vermelhos ondulados no código ou
entradas na Lista de Erros mostram erros antes mesmo de compilar e executar o
programa. Se os erros estiverem relacionados a nomes não resolvidos, você
provavelmente precisará adicionar uma referência ou uma diretiva using , ou ambos. Se
o código fizer referência a assemblies ou pacotes NuGet ausentes, você precisará
adicionar essas referências ao projeto.
O Visual Studio tenta ajudar você a identificar referências ausentes. Quando um nome
não é resolvido, um ícone de lâmpada é exibido no editor. Selecione a lâmpada para ver
sugestões de como corrigir o problema. As correções podem ser:
Adicionar uma diretiva using.

Adicionar uma referência a um assembly.
Instalar um pacote NuGet.
Adicionar uma diretiva using

Este é um exemplo de uma diretiva using ausente. Você pode adicionar using System;
ao início do arquivo de código para resolver o nome Console não resolvido:
As versões mais recentes do C# dão suporte a diretivas de uso implícito para alguns
namespaces comumente usados, portanto, se você escolher essa opção ao criar um
projeto, não precisará delas.
Adicionar uma referência de assembly

As referências do .NET podem ser assemblies ou pacotes NuGet. No código-fonte, o
editor ou autor geralmente explica de quais assemblies o código requer e de quais
pacotes ele depende. Para adicionar uma referência a um projeto manualmente, clique
com o botão direito do mouse no nó Referências no Gerenciador de Soluções e
escolha Adicionar Referência. No Gerenciador de Referência, localize e adicione o
assembly necessário.
Você pode encontrar assemblies e adicionar referências seguindo as instruções em

Adicionar ou remover referências usando o Gerenciador de Referência.
Adicionar um pacote NuGet
Se o Visual Studio detectar um pacote NuGet ausente, uma lâmpada será exibida e dará
a você a opção de instalar o pacote:
Se isso não resolver o problema ou se o Visual Studio não conseguir localizar o pacote,
tente pesquisar o pacote online. Confira Instalar e usar um pacote NuGet no Visual
Studio.
Usar a versão certa do .NET

Como diferentes versões do .NET Framework têm alguma compatibilidade com versões
anteriores, uma estrutura mais recente pode executar código escrito para uma estrutura
mais antiga sem nenhuma alteração. Mas, às vezes, você precisa definir uma versão do
.NET Framework específica como destino. Talvez seja necessário instalar uma versão
específica do .NET Framework ou do .NET Core. Consulte Modificar o Visual Studio.
Para alterar a versão do .NET Framework de destino, consulte Alterar a estrutura de

destino. Para obter mais informações, consulte Solução de problemas com erros de
definição de destino do .NET Framework.
Próximas etapas
Explore o ambiente de desenvolvimento do Visual Studio lendo Boas vindas ao IDE
do Visual Studio.
Criar seu primeiro aplicativo em C#.
Tutorial: abrir um projeto de um
repositório
Artigo • 04/12/2023
Neste tutorial, você usará o Visual Studio para se conectar a um repositório pela
primeira vez, cloná-lo e, em seguida, abrir um projeto nele.
Abrir um projeto de um repositório GitHub

com o Visual Studio 2019
A forma como você abre um projeto de um repositório do GitHub usando o Visual
Studio depende da versão que você tem. Especificamente, se você instalou o Visual
Studio 2019 versão 16.8 ou posterior, há uma experiência do Git no Visual Studio nova e
totalmente integrada disponível para você.
Mas não importa qual versão você instalou, você sempre pode abrir um projeto de um
repositório do GitHub com o Visual Studio.
Visual Studio 2019 versão 16.8 e posterior

Veja como usar o Git no Visual Studio 2019 versão 16.8 ou posterior.
Clonar um repositório GitHub e, em seguida, abrir um projeto

1. Abra o Visual Studio 2019.
2. Na janela inicial, selecione Clonar um repositório.

3. Insira ou digite a localização do repositório e, em seguida, selecione Clonar.
4. Você pode ser solicitado a fornecer informações de entrada do usuário na caixa de

diálogo Informações do Usuário do Git. Você pode adicionar suas informações ou
editar as informações padrão fornecidas.
Selecione Salvar para adicionar as informações ao arquivo .gitconfig global. (Ou
você pode selecionar Cancelar se quiser salvar as informações mais tarde.)
 Dica
Para obter mais informações sobre como entrar no Visual Studio, consulte a
página Entrar no Visual Studio. E para obter informações específicas sobre
como usar a conta do GitHub para entrar, consulte a página Trabalhar com
contas do GitHub no Visual Studio.
Em seguida, o Visual Studio carrega e abre automaticamente a solução do

repositório.
5. Se o repositório contiver várias soluções, o Gerenciador de Soluções as exibirá.
Para obter uma exibição de lista das soluções, selecione o botão Alternar
Exibições no Gerenciador de Soluções.
O Gerenciador de Soluções oferece a opção de abrir a pasta raiz no Modo de
Exibição de Pasta ou selecionar um arquivo de solução a ser aberto.
Para alternar o modo de exibição, selecione o botão Alternar Modos de Exibição

novamente.
 Dica
Você também pode usar o menu Git no Visual Studio IDE para clonar um
repositório e abrir um projeto.
Abrir um projeto localmente de um repositório GitHub clonado
anteriormente
1. Abra o Visual Studio 2019 versão 16.8 ou posterior.
2. Na janela de início, clique em Abrir um projeto ou uma solução.
O Visual Studio abre uma instância do Explorador de Arquivos, em que você pode
navegar até a solução ou projeto e selecioná-la para abrir.
Se você abriu o projeto ou a solução recentemente, selecione-o na seção Abrir

recente para abri-lo rapidamente novamente.
 Dica
Você também pode usar o menu Git no Visual Studio IDE para abrir pastas e
arquivos locais de um repositório clonado anteriormente.
Iniciar codificação!
Visual Studio 2019 versão 16.7 e anteriores

Veja como usar o Git no Visual Studio 2019 versão 16.7 ou anterior.
Clonar um repositório GitHub e, em seguida, abrir um projeto
1. Abra o Visual Studio 2019 versão 16.7 ou anterior.
2. Na janela de início, selecione Clonar ou verificar código.
3. Insira ou digite a localização do repositório e, em seguida, selecione Clonar.

O Visual Studio abre o projeto do repositório.
4. Se houver um arquivo de solução disponível, ele é exibido no menu suspenso

"Soluções e Pastas". Selecione-o, e o Visual Studio abrirá sua solução.
Se você não tiver um arquivo de solução (especificamente, um arquivo .sln) em seu
repositório, o menu suspenso diz "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ódigo do Visual Studio.
Iniciar codificação!
Navegue até um repositório do Azure DevOps

com o Visual Studio 2019
O que você vê quando navega e clona um repositório do Azure DevOps usando o Visual
Studio 2019 depende de qual versão você tem. Especificamente, se você instalou a
versão 16.8 ou posterior, alteramos a interface do usuário para acomodar uma nova
experiência do Git mais totalmente integrada no Visual Studio.
Mas não importa qual versão você instalou, você sempre pode procurar e clonar um
repositório do Azure DevOps com o Visual Studio.
Visual Studio 2019 versão 16.8 e posterior

1. Visual Studio 2019 versão 16.8 ou posterior.
2. Na janela inicial, selecione Clonar um repositório.
3. Na seção Navegar em um repositório, selecione Azure DevOps.
4. Se você vir uma janela de entrada, entre em sua conta.

5. Na caixa de diálogo Conectar-se a um Projeto, escolha o repositório a que você
deseja se conectar e selecione Clonar.
 Dica
Se você não vir uma lista pré-preenchida de repositórios aos quais se

conectar, selecione Adicionar Azure DevOps Server para inserir uma URL do
servidor. (Como alternativa, você pode ver um prompt "Nenhum servidor
encontrado" que inclui links para adicionar um Azure DevOps Server existente
ou criar uma conta do Azure DevOps.)
Em seguida, o Visual Studio abre o Gerenciador de Soluções que mostra as pastas
e os arquivos.
6. Selecione a guia Team Explorer para exibir as ações do Azure DevOps.
Visual Studio 2019 versão 16.7 e anteriores
1. Abra o Visual Studio 2019 versão 16.7 ou anterior.
2. Na janela de início, selecione Clonar ou verificar código.

3. Na seção Navegar em um repositório, selecione 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 selecione Clonar.
７ Observação
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, selecione 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
Fique à vontade para se aprofundar em qualquer um dos seguintes tutoriais específicos
da linguagem:
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
A experiência do Git no Visual Studio
Comparar o Git e o Team Explorer lado a lado
Introdução ao Azure DevOps
Azure DevOps Services: Introdução ao Azure Repos e ao Visual Studio
com C#
Artigo • 19/06/2023
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 C#.
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.
 Dica
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 menus, escolha Novo>Arquivo 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 chave de fechamento final } no arquivo e digite os

caracteres svm (que significam static void Main 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.

Examine os snippets de código disponíveis para a linguagem escolhendo
Editar>IntelliSense>Inserir Snippet ou pressionando Ctrl+K, Ctrl+X e, em seguida,
escolhendo a pasta da linguagem. 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() .
C#
// _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 Assinalar como comentário as linhas
selecionadas na barra de ferramentas. Caso prefira 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

Como não desejamos ver o construtor vazio que foi gerado para Class1 , vamos
recolhê-lo para que o código não seja mais exibido. Escolha a pequena caixa cinza com
o sinal de subtração dentro da margem da primeira linha do construtor. Ou, se você
preferir usar o teclado, posicione 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 adição ou pressione Ctrl+M, Ctrl+M novamente. Esse
recurso é chamado de Estrutura de tópicos e é útil principalmente ao recolher 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 em que o símbolo for
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. Se preferir, 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 valioso quando você está gravando o código. 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:

C#
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 .
C#
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 a definição da variável _words e selecione Renomear ao

clicar com o botão direito do mouse ou no menu de contexto, ou ao pressionar
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
Artigo • 18/01/2024
Para obter uma introdução à compilação com o IDE, veja Passo a passo: Criação de 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:
ﾉ Expandir a tabela
Método de build Benefícios
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 – Criar projetos C++ usando a ferramenta CMake

– Usar o mesmo sistema de build em plataformas Linux e Windows.
Linha de comando – Criar projetos sem instalar o Visual Studio.

do MSBuild – 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 CMake, MSBuild e Azure
Pipelines, respectivamente.
Compilando 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 obter uma introdução à compilação com o IDE, veja Passo a passo: Criação de um
aplicativo.
Em seguida, consulte Compilando e limpando projetos e soluções no Visual Studio para

saber mais sobre as diferentes personalizações 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:
Noções sobre configurações de build

Configurar projetos para plataformas de destino
Gerenciar propriedades de solução e de projeto.
Especificar eventos de build em C# e Visual Basic.
Definir opções de build
Compilar vários projetos paralelamente.
Conteúdo relacionado
Criar (compilar) projetos de site
Compilar e criar (Visual Studio para Mac)
Projetos do CMake no Visual Studio
Tutorial: aprenda a depurar código C#
usando o Visual Studio
Artigo • 25/10/2023
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 geralmente significa
que você está executando seu aplicativo com o depurador anexado. Quando você faz
essa tarefa, o depurador fornece várias maneiras de ver o que seu código está fazendo
enquanto ele é 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 este exercício for a primeira vez que você tentou
depurar um código, talvez você queira ler Depuração para iniciantes absolutos antes de
continuar neste artigo.
Embora o aplicativo de demonstração seja C#, a maioria dos recursos é aplicável a C++,
Visual Basic, F#, Python, JavaScript e outras linguagens compatíveis com o Visual Studio
(F# não dá suporte a 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 Desenvolvimento
multiplataforma do .NET Core.
Caso precise instalar a carga de trabalho, mas já tiver o Visual Studio, acesse
Ferramentas>Obter Ferramentas e Funcionalidades..., que abre o Instalador do Visual
Studio. O Instalador do Visual Studio é iniciado. Escolha a carga de trabalho
Desenvolvimento multiplaforma do .NET Core e selecione Modificar.
Criar um projeto
Primeiro, você cria um projeto de aplicativo de console do .NET Core. O tipo de projeto
vem com todos os arquivos de modelo que você precisa, antes mesmo de você
adicionar alguma coisa!
1. Abra o Visual Studio. Se a janela inicial não estiver aberta, selecione

Arquivo>Janela Inicial.
3. Na janela Criar um novo projeto, insira 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 e plataforma, escolha o modelo de

Aplicativo de Console para .NET Core e selecione Avançar.
７ Observação
Se não vir o modelo Aplicativo de Console, instale-o por meio 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, insira GetStartedDebugging na caixa Nome

do projeto. Em seguida, selecione Avançar.
5. Selecione a estrutura de destino recomendada (suporte ao .NET 8.0 ou a longo

prazo) e selecione Criar.
Criar o aplicativo
No Program.cs, substitua todo o código padrão pelo seguinte:
C#
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 (Depurar >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 carrega e você vê essa saída do console.
Prompt de comando do Windows
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, você examinará melhor este aplicativo usando o depurador e verá
os recursos do depurador.
2. Pare o depurador pressionando o botão de parada vermelha (Shift + F5).
3. Na janela do console, pressione uma tecla para fechá-la.
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 na seguinte linha de código:
name += letters[i];
Aparece um círculo vermelho no qual você definiu o ponto de interrupção.
Pontos de interrupção são um dos recursos mais básicos e essenciais de uma

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 fez uma 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 inicia o depurador e é

interrompido 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, confira Como usar 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 a execução de código é pausada na instrução name += letters[i] , passe

o mouse sobre a variável letters e você verá seu 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ê está tentando descobrir se as variáveis estão armazenando os
valores que você espera que eles tenham em um determinado momento.
2. Expanda a variável letters para ver suas propriedades, que incluem todos os
elementos que a variável contém.
3. Agora, passe o mouse sobre a variável name e você verá o valor atual dela: uma
cadeia de caracteres vazia.
4. Pressione F10 (ou escolha Depurar > Contornar) duas vezes para avançar para a
chamada de método SendMessage e pressione F10 mais uma vez.
Pressionar F10 avança o depurador até a próxima instrução sem intervir em

funções ou métodos no código do aplicativo (o código ainda é executado). Ao
pressionar F10 na chamada de método SendMessage , nós ignoramos o código de
implementação de SendMessage (que, no momento, talvez não seja de nosso
interesse).
5. Pressione F10 (ou Depurar>Contornar) algumas vezes para iterar várias vezes no
loop for , pausando novamente no ponto de interrupção e passando o mouse
sobre a variável name a cada vez para verificar o valor dela.
O valor da variável é alterado a cada iteração do loop for , mostrando valores de
f , depois fr , fre e assim por diante. Para avançar o depurador no loop mais
rapidamente nesse cenário, você pode pressionar F5 (ou escolher

Depurar>Continuar), avançando até o ponto de interrupção em vez da próxima
instrução.
Muitas vezes, ao depurar, 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 eles armazenem e as dicas de dados são uma boa maneira de fazer
isso.
6. Enquanto a execução de código permanece pausada no loop for no método

Main , pressione F11 (ou escolha Depurar > Depuração total) até pausar na
chamada de método SendMessage .
Você deve estar nessa linha de código:
SendMessage(name, a[i]);
7. Pressione F11 mais uma vez para intervir no método SendMessage .
O ponteiro amarelo avança para o método SendMessage .
F11 é o comando Intervir, 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 código que não é de usuário (se você
quiser mais detalhes, consulte Apenas Meu Código).
Digamos que você terminou de examinar o método SendMessage 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 Depurar > Sair).
Este 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 loop for do método Main , pausado na chamada de
método SendMessage . Para obter mais informações sobre diferentes maneiras de
percorrer seu código, confira Navegar pelo código no depurador.
Navegar usando Executar até o Clique

1. Selecione F5 para avançar para o ponto de interrupção novamente.
2. No editor de código, role para baixo e passe o mouse sobre o método

Console.WriteLine no método SendMessage até que o botão verde Executar até o
Clique apareça. A dica de ferramenta do botão mostra "Executar execução até

aqui".
７ Observação
O botão Executar até o Clique é novo no Visual Studio 2017. (Se o botão de
seta verde não for exibido, use F11 neste exemplo para avançar o depurador
até o lugar certo.)
3. Selecione o botão Executar para clicar.
O depurador avança até o método Console.WriteLine .
O uso desse botão é semelhante à configuração de um ponto de interrupção

temporário. Executar até o Clique é útil para se locomover rapidamente em uma
região visível do código do aplicativo (você pode selecionar em qualquer arquivo
aberto).
Reinicie o aplicativo rapidamente

Selecione o botão Reiniciar na Barra de Ferramentas de Depuração (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 vai parar novamente no ponto de interrupção que você definiu

anteriormente dentro do loop for .
Inspecionar variáveis com as janelas Autos e

Locais
1. Examine a janela Autos na parte inferior do editor de códigos.
Se estiver fechado, abra-o enquanto estiver em pausa no depurador escolhendo

Depurar>Janelas>Autos.
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 a variável letters 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

Na janela principal do editor de código, clique com o botão direito do mouse na
variável name 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 há uma inspeção definida na variável name e você pode ver o valor sendo
alterado enquanto percorre o depurador. Ao contrário das outras janelas variáveis, a
janela Inspeção sempre mostra as variáveis que você está assistindo (elas ficam
esmaecidas quando fora do escopo).
Examinar a pilha de chamadas

1. Enquanto a execução do código é pausada no loop for , selecione a janela Pilha
de Chamadas, que é aberta por padrão no painel inferior direito.
Se estiver fechado, abra-o enquanto estiver em pausa no depurador escolhendo

Depurar>Janelas>Pilha de Chamadas.
2. Selecione F11 algumas vezes até que o depurador seja pausado no método
SendMessage . 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.
７ Observação
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, que também altera o escopo atual em inspeção 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 o método Console.WriteLine .
2. Com o depurador pausado na chamada do método SendMessage , use o mouse

para pegar a seta amarela ou o ponteiro de execução (na margem esquerda) e
arraste o ponteiro para cima uma linha até a instrução Console.WriteLine .
3. Pressione F11.
O depurador executa novamente o método Console.WriteLine (você vê essa ação
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.
２ Aviso
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. Pode ser interessante ter uma visão geral de alto nível dos
recursos do depurador com links para mais informações.
Introdução ao depurador
Introdução ao teste de unidade
Artigo • 19/01/2024
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.
Neste artigo, o código usa C# e C++, as ilustrações estão em C#, mas os conceitos e
recursos se aplicam às linguagens .NET, C++, Python, JavaScript e TypeScript.
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 demonstrar um modelo de teste de unidade, este artigo testa um simples

projeto de Console C# ou C++ "Hello World" chamado HelloWorld. O código do
exemplo para um projeto desse tipo é o seguinte:
.NET
C#
namespace HelloWorld
{
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 o projeto de teste de unidade a ser

usado.
Digite teste na caixa de pesquisa para encontrar um modelo de projeto de teste de
unidade para a estrutura de teste que você deseja usar, como MSTest (C#) ou o
projeto teste de unidade nativa (C++) e selecione-o.
A partir do Visual Studio 2017 versão 14.8, as linguagens .NET incluem modelos
internos para NUnit e xUnit. Para C++, neste exemplo, selecione o projeto Teste de
Unidade Nativa, que usa o Microsoft Native Unit Test Framework. (Para usar uma
estrutura de teste do C++ diferente, consulte Gravando testes de unidade para
C/C++). Para Python, consulte Configurar o teste de unidade no código Python
para configurar seu projeto de teste.
 Dica
Somente para C#, você pode criar projetos de teste de unidade a partir do
código, usando um método mais rápido. Para obter mais informações,
consulte Criar projetos de teste de unidade e métodos de teste. Para usar
esse método com o .NET Core ou o .NET Standard, o Visual Studio 2019 ou
posterior é necessário.
A ilustração a seguir apresenta um teste de unidade MSTest, que tem suporte no

.NET.
Clique em Avançar, escolha um nome para o projeto de teste e, em seguida, clique

em Criar.
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 ou Adicionar
Referência de Projeto.
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, você pode usar o código a seguir selecionando a guia de

documentação correta que corresponda à estrutura de teste: MSTest, NUnit ou
xUnit (com suporte apenas no .NET) ou Estrutura de Teste de Unidade Nativa da
Microsoft para C++.
MSTest
C#
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);
HelloWorld.Program.Main();
var result = sw.ToString().Trim();

Assert.AreEqual(Expected, result);
}
}
}
}
Executar testes de unidade

1. Abra o Gerenciador de Testes.
Para abrir o Gerenciador de Testes, escolhaTeste>Gerenciador de Teste na barra

de menu superior (ou pressione Ctrl + E, T).
2. Execute seus testes de unidade clicando em Executar Tudo (ou pressione Ctrl + R,
V).
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.
 Dica
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 do teste de unidade ao vivo

(Visual Studio Enterprise)
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.
７ Observação
Para seguir estas etapas, o Visual Studio Enterprise é necessário, juntamente com o
código .NET e uma das seguintes estruturas de teste: MSTest, xUnit ou NUnit.
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.
Usar uma estrutura de teste de terceiros

Você pode executar testes de unidade no Visual Studio usando estruturas de teste de
terceiros, como NUnit, Boost ou Google C++ Testing Framework, dependendo da
linguagem de programação. Para usar uma estrutura de terceiros:
Use o Gerenciador de Pacotes NuGet para instalar o pacote do NuGet para a

estrutura de sua escolha.
(.NET) A partir do Visual Studio 2017, versão 14.6, o Visual Studio inclui modelos de
projeto de teste pré-configurados para estruturas de teste NUnit e xUnit. Os
modelos também incluem os pacotes NuGet necessários para habilitar o suporte.
(C++) No Visual Studio 2017 e versões posteriores, algumas estruturas, como a

Estrutura de Teste C++ do Google, já estão inclusas. Para obter mais informações,
consulte Gravar testes de unidade para C/C++ no Visual Studio.
Para adicionar um projeto de teste de unidade:
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 um modelo de projeto de teste de unidade.
Nesse exemplo, selecione NUnit

Clique em Avançar, nomeie o projeto e clique em Criar.
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 a partir do Gerenciador de Testes ou clicando com o botão direito
do mouse no código de teste e escolhendo Executar Teste(s) (ou Ctrl + R, T).
Próximas etapas
Noções básicas de teste de unidade
Criar e executar testes de unidade para código gerenciado
Escrever testes de unidade para C/C++

Documentação de implantação do
Visual Studio
Saiba como implantar aplicativos, serviços e componentes usando o Visual Studio
Sobre a implantação
ｅ VISÃO GERAL
Introdução à implantação
Visão geral da publicação
Aplicativos Web ASP.NET
ｇ TUTORIAL
Ferramenta de publicação
Obter configurações de publicação do IIS
Publicar com Git
Aplicativos C++
Pacote do instalador
Configurar projeto
Aplicativos ASP.NET Core
ｇ TUTORIAL
Ferramenta de publicação
ClickOnce
Empacotar um aplicativo da área de trabalho para a Windows Store
Aplicativos da área de trabalho do .NET Framework
ｇ TUTORIAL
ClickOnce
Implantar no Azure
ｇ TUTORIAL
Aplicativo ASP.NET Core para Serviço de Aplicativo
ASP.NET para Serviço de Aplicativo (.NET Framework)
Aplicativo Web do ASP.NET para Aplicativos Web do Azure
Aplicativo Web do ASP.NET para Aplicativos de Contêiner do Azure
Funções do Azure
Implantar com ações do GitHub
Implantar o aplicativo Entity Framework Core com GitHub Actions
Implantar contêineres do Docker
Implantar no Registro de Contêiner do Azure
Implantar no Serviço de Aplicativo do Azure
Implantar no Docker Hub

Implantar sem um Dockerfile
Tipos de implantação adicionais
Aplicativos Node.js no Serviço de Aplicativo do Linux
Aplicativos conteinerizados
Publicar pacotes do NuGet

Criar um banco de dados e adicionar
tabelas em aplicativos do .NET
Framework usando o Visual Studio
Artigo • 01/02/2024
７ Observação
Os conjuntos de dados e as classes relacionadas são tecnologias herdadas do .NET

Framework do início dos anos 2000 que permitem que os aplicativos trabalhem
com dados na memória enquanto os aplicativos estão desconectados do banco de
dados. Eles são bastante úteis em aplicativos que permitem que os usuários
modifiquem dados e persistam as alterações no banco de dados. Embora os
conjuntos de dados tenham se mostrado uma tecnologia muito bem-sucedida, é
recomendado que os novos aplicativos .NET usem o Entity Framework Core. O
Entity Framework proporciona uma forma mais natural de trabalhar com dados
tabulares como modelos de objeto e conta com uma interface de programação
mais simples.
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 Pesquisador de Objetos
do SQL Server no Visual Studio. Neste tópico, você cria um arquivo .mdf e adiciona
tabelas e chaves usando o Designer de Tabela.
Pré-requisitos
Para concluir este passo a passo, você precisa das cargas de trabalho de
desenvolvimento em .NET para desktop e Armazenamento e processamento de dados
instaladas no Visual Studio. Para instalá-las, abra Instalador do Visual Studio e escolha
Modificar (ou Mais>Modificar) ao lado da versão do Visual Studio que você deseja
modificar. Confira Modificar o Visual Studio.
７ Observação
Os procedimentos neste artigo se aplicam somente a projetos do Windows Forms

do .NET Framework, não a projetos do Windows Forms do .NET Core.
Criar um projeto e um arquivo de banco de
dados local
1. Crie um novo projeto Windows Forms App (.NET Framework) e nomeie-o como
SampleDatabaseWalkthrough.
2. Na barra de menus, escolha Projeto>Adicionar Novo Item. Se você vir uma caixa
de diálogo pequena com uma caixa para um nome de arquivo, escolha Mostrar
Todos os Modelos.
3. Na lista de modelos de item, role para baixo e selecione Banco de Dados baseado
em serviço.
4. Nomeie o banco de dados SampleDatabase.mdf 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 Janelas>Fontes de Dados na barra de menus.
2. Na janela Fontes de Dados, clique em 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 Banco de dados 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 (Conjunto de dados).
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
informando que o banco de dados não contém nenhum objeto. Escolha Concluir.
Exibir propriedades da conexão de dados

Você pode exibir algumas das propriedades do arquivo SampleDatabase.mdf abrindo a
janela Propriedades da conexão de dados:
Selecione Exibir>Pesquisador de Objetos do SQL Server (ou Ctrl+\, Ctrl+S) para

abrir a janela Pesquisador de Objetos do SQL Server. Expanda
(localdb)\MSSQLLocalDB>Bancos de Dados e clique com o botão direito em
SampleDatabase.mdf (ele pode estar listado como um caminho completo) e
selecione Propriedades.
Como alternativa, você pode selecionar Exibir>Gerenciador de Servidores, 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 em SampleDatabase.mdf e
selecionando Propriedades.
 Dica
Se você não puder expandir o nó Conexões de Dados ou a conexão

SampleDatabase.mdf não estiver listada, selecione o botão Conectar-se ao
Banco de Dados na barra de ferramentas de Gerenciador de Servidores. Na
caixa de diálogo Adicionar Conexão, verifique se o Arquivo de Banco de
Dados do Microsoft SQL Server está selecionado em Fonte de dados e, em
seguida, navegue e selecione o arquivo SampleDatabase.mdf. Conclua a
adição da conexão selecionando OK.
Para exibir a cadeia de conexão, você pode abrir o arquivo App.config no Gerenciador de
Soluções. Você deve ver uma entrada sob o elemento connectionStrings semelhante ao
seguinte código:
XML
<connectionStrings>
<add
name="SampleDatabaseWalkthrough.Properties.Settings.SampleDatabaseConnection
String"
connectionString="Data Source=
(LocalDB)\MSSQLLocalDB;AttachDbFilename=|DataDirectory|\SampleDatabase.mdf;I
ntegrated Security=True"
providerName="System.Data.SqlClient" />
</connectionStrings>
Criar tabelas e chaves usando o Designer de

Tabela
Nesta seção, você criará algumas 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 podem corresponder aos registros na outra tabela.
Criar a tabela Clientes

1. No Gerenciador de Servidores ou Navegador de Objetos do SQL Server, expanda
o nó Conexões de Dados e, em seguida, expanda o nó SampleDatabase.mdf.
2. Clique com o botão direito 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:
Nome da coluna Tipo de dados Permitir nulos
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 na linha CustomerID e selecione Definir Chave
Primária.
5. Clique com o botão direito 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:
SQL
CREATE TABLE [dbo].[Customers]
7. Adicione uma restrição de índice à tabela Clientes. Adicione uma vírgula no final
da linha Phone e adicione o seguinte exemplo antes do parêntese de fechamento:
SQL
CONSTRAINT [PK_Customers] PRIMARY KEY ([CustomerID])
Você deverá ver algo como:
8. No canto superior esquerdo do Designer de Tabela, selecione Atualizar ou

pressione Shift+Alt+U.
9. Na caixa de diálogo Visualizar Atualizações de Banco de Dados, selecione

Atualizar Banco de Dados.
A tabela Clientes é criada no arquivo de banco de dados local.
Criar a tabela Pedidos

1. Adicione outra tabela e uma linha para cada entrada na seguinte tabela:
Nome da coluna Tipo de dados Permitir nulos
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:
SQL
CREATE TABLE [dbo].[Orders]
4. Adicione uma restrição de índice à tabela Clientes. Adicione uma vírgula no final
da linha OrderQuantity e adicione o seguinte exemplo antes do parêntese de
fechamento:
SQL
CONSTRAINT [PK_Orders] PRIMARY KEY ([OrderId])
5. No canto superior esquerdo do Designer de Tabela, selecione Atualizar ou

pressione Shift+Alt+U.

A tabela Pedidos é criada no arquivo de banco de dados local. Se você expandir o

nó Tabelas no Gerenciador de Servidores, verá as duas tabelas:
Se você não o vir, pressione o botão Atualizar da barra de ferramentas.
Criar uma chave estrangeira

1. No painel de contexto no lado direito da grade Designer de Tabela da tabela
Pedidos, 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 ToTable por Clientes.
3. No painel T-SQL, atualize a última linha de acordo com o seguinte exemplo:
SQL
CONSTRAINT [FK_Orders_Customers] FOREIGN KEY ([CustomerID]) REFERENCES

[Customers]([CustomerID])
4. No canto superior esquerdo do Designer de Tabela, selecione Atualizar
(Shift+Alt+U).

A chave estrangeira é criada.
Preencher as tabelas com dados

1. No Gerenciador de Servidores ou no Pesquisador de Objetos do SQL Server,
expanda o nó do banco de dados de exemplo.
2. Abra o menu de atalho do nó Tables, selecione Atualizar e, em seguida, expanda o

nó Tables.
3. Abra o menu de atalho da tabela Cientes e, em seguida selecione Mostrar Dados

da Tabela ou Exibir Dados.
4. Adicione os 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, em seguida, escolha Mostrar Dados

da Tabela ou Exibir Dados.
6. Adicione dados para alguns pedidos. À medida que você insere cada linha, ela é
salva no banco de dados.
） Importante
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.
Parabéns! Agora você sabe como criar tabelas, vinculá-las a uma chave estrangeira e
adicionar dados.
Conteúdo relacionado
Acessando dados no Visual Studio

Visualstudio Get Started Csharp Vs 2019

Enviado por

Direitos autorais:

Formatos disponíveis

Visualstudio Get Started Csharp Vs 2019

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

Visualstudio Get Started Csharp Vs 2019

Enviado por

Direitos autorais:

Formatos disponíveis

Dê a sua opinião sobre a experiência de download do PDF.

Tutoriais do Visual Studio | C#

Baixar e instalar o Visual Studio

Iniciar um tour guiado

Criar um aplicativo Web "Olá, Mundo"

Criar um aplicativo de console

Criar um aplicativo Web

Criar um aplicativo SDK do aplicativo do Windows

Criar um aplicativo da área de trabalho do Windows

Criar um aplicativo do Windows Forms

Saiba mais sobre a linguagem C#

Jogo de correspondência do Windows Forms

Teste de matemática do Windows Forms

Visualizador de imagens do Windows Forms

Aprender a usar o Visual Studio

Abrir código de um repositório

Escrever e editar o código

Depurar seu código

Testar seu código

Um ambiente de desenvolvimento integrado (IDE) é um programa repleto de recursos

No Gerenciador de Soluções, no canto superior direito, você pode exibir, navegar e

A janela do editor central, na qual você provavelmente passará a maior parte do

Em Alterações do Git, no canto inferior direito, você pode acompanhar itens de

Há três edições do Visual Studio: Community, Professional e Enterprise. Consulte

Recursos de produtividade populares

Rabiscos e Ações Rápidas

A refatoração inclui operações como renomeação inteligente de variáveis, extração

IntelliSense é um conjunto de recursos que exibe informações sobre seu código

Os recursos do IntelliSense variam de acordo com a linguagem. Para saber mais,

Pesquisa do Visual Studio

Os menus, as opções e as propriedades do Visual Studio podem parecer

Edite e depure de maneira colaborativa com outras pessoas em tempo real,

A janela Hierarquia de Chamadas mostra os métodos que chamam um método

O CodeLens ajuda você a encontrar referências de código, alterações de código,

A funcionalidade Ir para Definição leva você diretamente para a localização de

Instalar o Visual Studio

1. Abra o Visual Studio.

A janela de início é exibida com opções para clonar um repositório, abrir um

2. Escolha Criar um novo projeto.

Selecione o modelo Aplicativo de Console e depois clique em Avançar.

4. Na janela Configurar seu novo projeto, insira OláMundo na caixa Nome do

Em breve, você deverá ver algo parecido com a tela a seguir:

Há outros menus e outras janelas de ferramentas disponíveis, mas por enquanto,

O Visual Studio compila o aplicativo e uma janela do console é aberta com a

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

8. Vamos acrescentar mais alguns códigos ao aplicativo. Adicione o código C# a

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

9. Altere a linha que indica Console.WriteLine("Hello World!"); para o seguinte

10. Execute o aplicativo novamente, selecionando Depurar>Iniciar Sem Depuração ou

O Visual Studio recompila o aplicativo e uma janela do console é aberta e solicita

11. Insira seu nome na janela do console e pressione Enter.

Usar a refatoração e o IntelliSense

Primeiro, renomeie a variável name :

Uma caixa aparece ao redor da variável e uma lâmpada é exibida na margem.

2. Selecione o ícone de lâmpada para mostrar as Ações Rápidas disponíveis.

3. Agora dê uma olhada no IntelliSense. Abaixo da linha que mostra

Uma caixa exibe os membros da classe DateTime. A descrição do membro

4. Selecione o membro chamado Agora, que é uma propriedade da classe, clicando

5. Abaixo dessa linha, insira as linhas de código a seguir: