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

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

ｃ GUIA DE INSTRUÇÕES

Acessar dados
Bem-vindo ao IDE do Visual Studio | C#
Artigo • 18/03/2023 • 15 minutos para o fim da leitura

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.

Hot Reload
 A Recarga Dinâmica permite editar os arquivos de código do aplicativo e aplicar as
alterações de código imediatamente ao aplicativo em execução.

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. No instalador modular,

você escolhe e instala cargas de trabalho, que são grupos de recursos necessários para
as linguagens de programação ou plataformas que você deseja. Para usar as etapas a
seguir para criar um programa, selecione a carga de trabalho Desenvolvimento de
desktop do .NET 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. Inicie 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 um modelo, você pode digitar ou inserir palavras-chave na caixa de

pesquisa. A lista de modelos disponíveis filtra com base nas palavras-chave que
você inserir. Você pode filtrar ainda mais os resultados de 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 selecione Avançar.

4. Na janela Configurar seu novo projeto, insira OláMundo na caixa Nome do
projeto. Opcionalmente, altere o local do diretório do projeto a partir do local
padrão do C:\Users\<name>\source\repos e selecione Avançar.

5. Na janela Informações adicionais, verifique se o .NET 6.0 aparece no menu

suspenso Estrutura de Destino e selecione Criar.
O Visual Studio cria o projeto. O programa é um aplicativo simples "Olá, Mundo"
que chama o método [Link]() para exibir a cadeia de caracteres Olá,
Mundo! em uma janela de console.

Os arquivos de projeto aparecem no lado direito do IDE do Visual Studio, em uma

janela chamada Gerenciador de Soluções. Na janela Gerenciador de Soluções,
selecione o arquivo [Link]. O código C# para seu aplicativo abre na janela do
editor central, que ocupa a maior parte do espaço.

O código fica automaticamente colorido para indicar diferentes partes, como

palavras-chave e tipos. Os números de linha ajudam você a localizar o código.
 Linhas tracejadas pequenas e verticais no código indicam quais chaves
correspondem umas às outras. Você também pode escolher os sinais de subtração
ou adição pequenos demarcados para recolher ou expandir blocos de código. Esse
recurso de destaque do código permite ocultar os códigos que não precisam ser
vistos, ajudando a minimizar a desordem na tela.

Muitos outros menus e janelas de ferramentas estão disponíveis.

6. Inicie o aplicativo escolhendo Depurar>Iniciar Sem Depuração no menu superior

do Visual Studio. 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 de console, pressione qualquer tecla.

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

seguir antes da linha que diz [Link]("Hello World!"); :

C#

[Link]("\nWhat is your name?");

var name = [Link]();
 Esse código exibe Qual é seu nome? na janela do console e, em seguida, aguarda
até que o usuário insira um texto.

9. Altere a linha que indica [Link]("Hello World!"); para a linha a seguir:

C#

[Link]($"\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. Digite 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

[Link]($"\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 = [Link]; .

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

C#

int dayOfYear = [Link];

[Link]("Day of year: ");

[Link](dayOfYear);

 Dica

[Link] é diferente de [Link], 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 = [Link]; . 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

[Link]($"\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.

Depois que o aplicativo estiver em execução, você poderá aplicar alterações de código
ao aplicativo em execução clicando no botão Recarga Dinâmica.

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 Azul

ou Claro e depois selecione OK.

O tema de cores para todo o IDE é alterado em conformidade. A captura de tela a

seguir mostra o tema Azul:
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 [Link] .
Leia o blog do Visual Studio .
Saiba como usar o editor de código com
C#
Artigo • 28/09/2022 • 11 minutos para o fim da leitura

Aplica-se a: Visual Studio Visual Studio para Mac Visual Studio Code

Nesta introdução de 10 minutos ao editor de código no Visual Studio, adicionaremos

código a um arquivo para examinar algumas das maneiras que o Visual Studio facilita a
gravação, a navegação e a compreensão do código C#.

Se você ainda não instalou o Visual Studio, acesse a página de 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
[Link] 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 escolha Continuar sem código na janela
inicial 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#. Você
não precisa criar um projeto completo do Visual Studio para obter alguns dos
 benefícios que o editor de código oferece– tudo o que você precisa é de 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 . svm static void Main significa — não se preocupe se você ainda
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á a assinatura do static void Main() método ser adicionada ao arquivo.
O método Main() é o ponto de entrada para aplicativos C#.

Os snippets de código disponíveis variam para diferentes linguagens de programação.

Você pode examinar os snippets de código disponíveis para seu idioma escolhendo
Editar>Snippet de Inserçãodo IntelliSense> ou pressionando Ctrl+K, Ctrl+X e
escolhendo a pasta para sua linguagem de programação. Para C#, a lista de snippets
tem esta aparência:

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 na barra de menus do Visual Studio,
ajuda a torná-lo mais produtivo conforme você codifica. Por exemplo, você pode
alternar o modo de conclusão do IntelliSense , aumentar ou diminuir um recuo de linha
ou comentar o código que não deseja compilar.

Vamos comentar algum código.

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

C#

// someWords is a string array.

string[] someWords = {
"the",
"quick",
"brown",
"fox",
"jumps"
};

string[] moreWords = {
"over",
"the",
"lazy",
"dog"
};

// Alphabetically sort the words.

IEnumerable<string> query = from word in someWords
orderby word
select word;

2. Não estamos usando a moreWords variável, mas podemos usá-la mais tarde para
que não queiramos excluí-la. Em vez disso, vamos comentar essas linhas. Selecione
toda a definição de moreWords até o ponto e vírgula de fechamento e escolha o
botão Comentar as linhas selecionadas na barra de ferramentas. Se preferir usar o
teclado, pressione Ctrl+E, Ctrl+C.
 Os caracteres de comentários // de C# são adicionados ao início de cada linha
selecionada para comentar o código.

Recolher blocos de código

Não queremos ver o construtor vazio para o qual foi gerado Class1 , portanto, para
desabar nossa visão do código, vamos recolhê-lo. Escolha a pequena caixa cinza com o
sinal de subtração dentro da margem da primeira linha do construtor. Ou, se preferir
usar o teclado, coloque o cursor em qualquer lugar no código do construtor e pressione
Ctrl+M, Ctrl+M.

O bloco de código é recolhido apenas na primeira linha, seguido por um sinal de

reticências ( ... ). Para expandir o bloco de código novamente, selecione a mesma caixa
cinza que agora tem um sinal de adição ou pressione Ctrl+M, Ctrl+M novamente. Esse
recurso é chamado Delineamento e é especialmente útil quando você está recolhindo
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 ou
variável. Uma maneira é ir para a definição, em qualquer arquivo que o tenha,
escolhendo Ir para Definição ou pressionando F12 em qualquer lugar em que um
símbolo for referenciado. Uma maneira ainda mais rápida que não afasta seu foco do
código em que você está trabalhando é usar a Definição de Espiada.

Vamos espiar a definição do tipo string .

1. Clique com o botão direito do mouse em qualquer ocorrência de string e escolha

Espiar Definição no menu de conteúdo. Ou pressione Alt+F12.

Uma janela pop-up será exibida com a definição da classe String . Você pode rolar
na janela pop-up ou até mesmo inspecionar a definição de outro tipo do código
 inspecionado.

2. Feche a janela de definição de espiada escolhendo a caixa pequena com um "x" no

canto superior direito da janela pop-up.

Usar o IntelliSense para completar palavras

O IntelliSense é um recurso inestimável quando você está codificando. Ele pode mostrar
informações sobre membros disponíveis de um tipo ou detalhes de parâmetros para
sobrecargas diferentes de um método. Você também pode usar o IntelliSense para
completar uma palavra depois que você digitar caracteres suficientes para desambiguá-
la.

Vamos adicionar uma linha de código para imprimir as cadeias de caracteres ordenadas
na janela de console, que é o local padrão para envio da saída do programa.

1. Abaixo da variável query , comece a digitar o código a seguir:

C#

foreach (string str in qu

Você verá um pop-up do IntelliSense aparecer com informações sobre o query

símbolo.
 2. Para inserir o restante da palavra query usando a conclusão da palavra IntelliSense,
pressione Tab.

3. Finalize o bloco de código para que ele se pareça com o seguinte código. Você
pode praticar mais com snippets de código inserindo e pressionando cw Tab duas
vezes para gerar a [Link] instrução.

C#

foreach (string str in query)

{
[Link](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 someWords como
unsortedWords .

1. Coloque o cursor sobre a definição da someWords variável e escolha Renomear no

menu de contexto ou clique com o botão direito do mouse ou no menu ou
pressione F2.

Uma caixa de diálogo Renomear aparece na parte superior direita do editor.

 2. Insira o nome desejado unsortedWords. Você verá que a referência na
unsortedWords query instrução de atribuição também é renomeada
automaticamente. Antes de pressionar Enter, marque a caixa de seleção Incluir
Comentários na caixa pop-up Renomear.

3. Pressione Enter ou escolha Aplicar na caixa de diálogo Renomear .

Ambas as ocorrências de someWords seu código foram renomeada, bem como o

texto someWords em seu comentário de código.

Próximas etapas
Saiba mais sobre projetos e soluções

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 • 18/03/2023 • 10 minutos para o fim da leitura

Aplica-se a: Visual Studio Visual Studio para Mac Visual Studio Code

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, acesse a página Downloads do Visual
Studio para instalá-lo gratuitamente.

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.
 1. Abra o Visual Studio e, na janela de início, selecione Criar um novo projeto.

2. 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 por Outros resultados com base na sua pesquisa para
localizar o modelo.

3. Na página Configurar seu novo projeto, nomeie a solução QuickSolution e

selecione Criar.

A solução QuickSolution aparece no Gerenciador de Soluções do lado direito da

janela do Visual Studio. Provavelmente, você usará o Gerenciador de Soluções
para navegar pelos conteúdos 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. Clique com o botão direito do mouse na Solução ´QuickSolution’ no Gerenciador
de Soluções, selecione Adicionar>Novo Projeto do menu de contexto.

2. Na página Adicionar um novo projeto, digite vazio na caixa de pesquisa na parte

superior e selecione C# em Todos os idiomas.

3. Selecione o modelo #C Projeto Vazio (.NET Framework) e, em seguida, Avançar.

７ Observação

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. Se você não visualizar o modelo Projeto Vazio (.NET Framework),
será necessário instalar a carga de trabalho do Visual Studio de
desenvolvimento para área de trabalho do .NET.

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?. No Instalador do Visual
Studio, selecione a carga de trabalho de desenvolvimento para área de
trabalho do .NET e, em seguida, escolha Modificar.

4. Na página Configurar seu novo projeto, nomeie o projeto QuickDate e selecione

Criar.

O projeto QuickDate aparece na solução em Gerenciador de Soluções. O projeto

contém um nó Referências e um único arquivo chamado [Link].

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.

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 [Link] ao projeto. O .cs no final
é a extensão de arquivo fornecida aos arquivos de código C#. O arquivo
[Link] aparece na hierarquia do projeto visual Gerenciador de Soluções e o
arquivo é aberto no editor.

3. Substitua o conteúdo do arquivo [Link] pelo seguinte código:

C#

using System;

namespace QuickDate
{
internal class Calendar
{
static void Main(string[] args)
{
DateTime now = GetCurrentDate();
[Link]($"Today's date is {now}");
[Link]();
}

internal static DateTime GetCurrentDate()

{
return [Link];
}
}
}

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 teste de unidade na caixa de

pesquisa na parte superior e, em seguida, selecione C# em Todos os idiomas.
 3. Selecione o modelo de projeto #C Projeto de Teste de Unidade (.NET Framework)
e selecione Avançar.

4. Na página Configurar seu novo projeto, nomeie o projeto QuickTest e selecione

Criar.

O Visual Studio adiciona o projeto QuickTest a Gerenciador de Soluções e o

arquivo [Link] é 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. No Gerenciador de Soluções, clique com o botão direito do mouse no nó

Referências do projeto QuickTest e selecione Adicionar Referência no menu de
contexto.

2. Na caixa de diálogo Gerenciador de Referência, selecione Projetos. No painel

central, selecione a caixa de seleção ao lado de QuickDate e, em seguida,
selecione OK.

Uma referência ao projeto QuickDate aparece no projeto QuickTest em

Gerenciador de Soluções.
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 [Link] pelo seguinte código:

C#

using System;
using [Link];

namespace QuickTest
{
[TestClass]
public class UnitTest1
{
[TestMethod]
public void TestGetCurrentDate()
{
[Link]([Link],
[Link]());
}
}
}
 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 [Link], adicione a instrução using a seguir e o

InternalsVisibleToAttributeatributo à parte superior do arquivo, para resolver o erro
no projeto de teste.

C#

using [Link];

[assembly: InternalsVisibleTo("QuickTest")]

O código [Link] 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 [Link] 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 [Link] 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 • 27/09/2022 • 7 minutos para o fim da leitura

Aplica-se a: Visual Studio Visual Studio para Mac Visual Studio Code

Este artigo descreve os recursos para desenvolvedores experientes ou desenvolvedores

que já estão familiarizados com o Visual Studio. Para obter uma introdução básica ao
Visual Studio, consulte 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 . As cargas de trabalho são grupos de recursos que as linguagens de
programação ou plataformas precisam trabalhar. Essa estratégia modular ajuda a
manter o volume de instalação do Visual Studio menor, para que ele seja instalado e
atualizado mais rapidamente.

Se você ainda não instalou o Visual Studio, acesse a página de downloads do Visual
Studio para instalá-lo gratuitamente.

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 facilmente aplicativos
habilitados para nuvem do Microsoft Azure. 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.

） Importante
 A janela do Cloud Explorer está desativada no Visual Studio 2022. Para obter mais
informações, consulte Gerenciar os recursos associados às suas contas do Azure
no Visual Studio Cloud Explorer.

Use o portal do Azure para acessar os recursos do Azure conforme necessário. Você
pode continuar a usar o nó do Azure do Gerenciador de Servidores em versões
anteriores do Visual Studio.

Você pode 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 Active Directory
(Azure AD) 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 em Gerenciador de Soluções
e escolhendo Adicionar>Serviço Conectado.

Na tela Serviços Conectados , selecione o link ou o sinal de adição para Adicionar uma
dependência de serviço. Na tela Adicionar dependência , selecione o serviço que você
deseja adicionar e siga as telas para se conectar à sua assinatura e serviço do Azure.
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 ajudá-lo a escrever aplicativos para a Web. Você pode criar
aplicativos Web usando [Link], [Link], Python, JavaScript e TypeScript. O Visual
Studio dá suporte a muitas estruturas da Web, como Angular, jQuery e Express.

[Link] Core e .NET Core são executados em sistemas operacionais Windows, Mac e
Linux. [Link] Core é uma atualização importante para MVC, WebAPI e SignalR.
[Link] Core foi projetado desde o início para fornecer uma pilha .NET enxuta e
redigida para a criação de aplicativos e serviços 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 e 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 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 gerenciar instâncias de servidor e
ativos localmente, remotamente e no Azure, Microsoft 365, [Link] e 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.

SQL Server Pesquisador de Objetos fornece uma exibição dos objetos de banco de
dados, semelhante a SQL Server Management Studio. Com SQL Server Pesquisador de
Objetos, você pode executar o trabalho de design e administração de banco de dados
light-duty. Exemplos incluem editar dados de tabela, comparar esquemas e executar
consultas usando menus contextuais.

Para abrir SQL Server Pesquisador de Objetos, selecione seu ícone na parte superior da
janela do Gerenciador de Servidores ou selecione Exibição>SQL Server Pesquisador de
Objetos no menu superior do Visual Studio.

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, manter e refatorar bancos de dados. Você pode
trabalhar com um projeto de banco de dados ou diretamente com uma instância local
ou não de banco de dados conectado. Para obter o SSDT, use o Instalador do Visual
Studio para instalar a carga de trabalho de armazenamento e processamento de
dados.
Depurar, testar e melhorar o código
Ao escrever código, você deve executá-lo e testá-lo para bugs e desempenho. Com o
sistema de depuração do Visual Studio, você pode depurar o código em execução em
seu projeto local, em um dispositivo remoto ou em um emulador de dispositivo.
Percorra o código uma instrução de cada vez e inspecione as variáveis conforme você
vai. Ou defina pontos de interrupção que só são atingidos quando uma condição
especificada é verdadeira. Você pode gerenciar as opções de depuração no próprio
editor de código, para que não precise deixar seu código.

Para obter mais informações sobre a depuração no Visual Studio, consulte Primeiro
examinar 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 teste , como teste de unidade, Live Unit Testing,
IntelliTest e teste de carga e desempenho. O Visual Studio também tem recursos
avançados de análise de código para localizar design, segurança e outras falhas.

Implantar o aplicativo concluído

O Visual Studio tem ferramentas para implantar seu aplicativo para usuários ou clientes
por meio da Microsoft Store, um site do SharePoint ou 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 seu 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.

Para obter detalhes completos, consulte a experiência do Git na página do Visual Studio
e na página de navegação da documentação de controle de versão do Visual Studio . E,
para obter 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 .
  Dica

Continuamos compilando o conjunto de recursos do Git e iteramos nele com base

em seus comentários. Para obter mais informações sobre uma atualização de
recursos recente, juntamente com um link para a pesquisa em que você pode
compartilhar seus comentários sobre ele, consulte o suporte a vários repositórios
na postagem no blog do Visual Studio.

Próximas etapas
Se o Visual Studio não tiver a funcionalidade exata necessária, você poderá
adicioná-la. Personalize o IDE com base em seu fluxo de trabalho e estilo, adicione
suporte a ferramentas externas que não estão integradas ao Visual Studio e
modifique a funcionalidade existente para aumentar sua produtividade. Para obter
a versão mais recente do VS SDK (Ferramentas de Extensibilidade do Visual
Studio), consulte o 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
Novidades no Visual Studio 2019
Novidades no Visual Studio 2022
Tutorial: Criar um aplicativo de console
simples em C# no Visual Studio (parte 1
de 2)
Artigo • 17/03/2023 • 17 minutos para o fim da leitura

Aplica-se a: Visual Studio Visual Studio para Mac Visual Studio Code

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ê:

＂ 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.

Se você ainda não tiver instalado o Visual Studio, acesse a página Downloads do Visual
Studio para instalá-lo gratuitamente.

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 escolha Criar um novo projeto na janela Iniciar.

2. Na janela Criar um projeto, selecione Todas as linguagens e, em seguida, escolha
C# na lista suspensa. Escolha Windows na lista Todas as plataformas e Console na
lista Todos os 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, escolha a carga de trabalho de

desenvolvimento para área de trabalho do .NET e, em seguida, escolha
Modificar.
3. Na janela Configurar seu novo projeto, digite ou insira Calculadora na caixa Nome
do projeto e, em seguida, selecione Avançar.

4. Na janela Informações adicionais, o .NET 6.0 já deve estar selecionado para sua
estrutura de destino. 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 [Link] na janela

Gerenciador de Soluções, que normalmente está no lado direito do Visual Studio.
 A declaração de código único 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.

７ Observação

A partir do .NET 6, novos projetos que usam o modelo do console geram

código diferente das versões anteriores. Para saber mais, confira a página
Novos modelos C# geram instruções de nível superior.

Criar o aplicativo
Nesta seção, você:

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 painel direito do Gerenciador de Soluções, selecione [Link] para exibir o

arquivo no editor de código

2. No editor de código, substitua o código padrão "Olá, Mundo" que diz

[Link]("Hello World!"); .
Substitua a linha pelo código a seguir:

C#

int a = 42;
int b = 119;
int c = a + b;
[Link](c);
[Link]();

Se você digitar o código, o recurso IntelliSense do Visual Studio oferecerá a opção

de preenchimento automático da entrada.
 3. Para compilar e executar seu aplicativo, pressione F5 ou selecione a seta verde ao
lado do nome Calculadora na barra de ferramentas superior.

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

4. Feche a janela do console.

5. Opcionalmente, 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. Quando você

executa o aplicativo, o resultado é alterado adequadamente.

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 [Link] pelo novo código:

C#

// Declare variables and then initialize to zero.

int num1 = 0; int num2 = 0;

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

[Link]("Console Calculator in C#\r");
[Link]("------------------------\n");

// Ask the user to type the first number.

[Link]("Type a number, and then press Enter");
num1 = Convert.ToInt32([Link]());

// Ask the user to type the second number.

[Link]("Type another number, and then press Enter");
num2 = Convert.ToInt32([Link]());

// Ask the user to choose an option.

[Link]("Choose an option from the following list:");
[Link]("\ta - Add");
 [Link]("\ts - Subtract");
[Link]("\tm - Multiply");
[Link]("\td - Divide");
[Link]("Your option? ");

// Use a switch statement to do the math.

switch ([Link]())
{
case "a":
[Link]($"Your result: {num1} + {num2} = " +
(num1 + num2));
break;
case "s":
[Link]($"Your result: {num1} - {num2} = " +
(num1 - num2));
break;
case "m":
[Link]($"Your result: {num1} * {num2} = " +
(num1 * num2));
break;
case "d":
[Link]($"Your result: {num1} / {num2} = " +
(num1 / num2));
break;
}
// Wait for the user to respond before closing.
[Link]("Press any key to close the Calculator console
app...");
[Link]();

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 [Link] 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.

1. 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
[Link] .

2. 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 ele ainda não trata 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.

Para alterar o código para tratar esse erro:

1. Em [Link], 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)
{
[Link]("Enter a non-zero divisor: ");
num2 = Convert.ToInt32([Link]());
}
[Link]($"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 [Link], 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 = [Link]; // Default value is "not-a-number"
if an operation, such as division, could result in an error.

// Use a switch statement to do the math.

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
{
static void Main(string[] args)
{
bool endApp = false;
// Display title as the C# console calculator app.
[Link]("Console Calculator in C#\r");
[Link]("------------------------\n");
 while (!endApp)
{
// Declare variables and set to empty.
string numInput1 = "";
string numInput2 = "";
double result = 0;

// Ask the user to type the first number.

[Link]("Type a number, and then press Enter: ");
numInput1 = [Link]();

double cleanNum1 = 0;
while ()
{
[Link]("This is not valid input. Please enter an
integer value: ");
numInput1 = [Link]();
}

// Ask the user to type the second number.

[Link]("Type another number, and then press Enter:
");
numInput2 = [Link]();

double cleanNum2 = 0;
while ()
{
[Link]("This is not valid input. Please enter an
integer value: ");
numInput2 = [Link]();
}

// Ask the user to choose an operator.

[Link]("Choose an operator from the following
list:");
[Link]("\ta - Add");
[Link]("\ts - Subtract");
[Link]("\tm - Multiply");
[Link]("\td - Divide");
[Link]("Your option? ");

string op = [Link]();

try
{
result = [Link](cleanNum1, cleanNum2,
op);
if ([Link](result))
{
[Link]("This operation will result in a
mathematical error.\n");
}
else [Link]("Your result: {0:0.##}\n",
result);
 }
catch (Exception e)
{
[Link]("Oh no! An exception occurred trying
to do the math.\n - Details: " + [Link]);
}

[Link]("------------------------\n");

// Wait for the user to respond before closing.

[Link]("Press 'n' and Enter to close the app, or
press any other key and Enter to continue: ");
if ([Link]() == "n") endApp = true;

[Link]("\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 [Link] é 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 = [Link]; // Default value is "not-a-number" which
we use if an operation, such as division, could result in an error.

// Use a switch statement to do the math.

switch (op)
{
case "a":
result = num1 + num2;
break;
case "s":
result = num1 - num2;
break;
case "m":
result = num1 * num2;
break;
case "d":
// Ask the user to enter a non-zero divisor.
if (num2 != 0)
{
result = num1 / num2;
}
break;
// Return text for an incorrect option entry.
 default:
break;
}
return result;
}
}

class Program
{
static void Main(string[] args)
{
bool endApp = false;
// Display title as the C# console calculator app.
[Link]("Console Calculator in C#\r");
[Link]("------------------------\n");

while (!endApp)
{
// Declare variables and set to empty.
string numInput1 = "";
string numInput2 = "";
double result = 0;

// Ask the user to type the first number.

[Link]("Type a number, and then press Enter: ");
numInput1 = [Link]();

double cleanNum1 = 0;
while ()
{
[Link]("This is not valid input. Please enter an
integer value: ");
numInput1 = [Link]();
}

// Ask the user to type the second number.

[Link]("Type another number, and then press Enter: ");
numInput2 = [Link]();

double cleanNum2 = 0;
while ()
{
[Link]("This is not valid input. Please enter an
integer value: ");
numInput2 = [Link]();
}

// Ask the user to choose an operator.

[Link]("Choose an operator from the following
list:");
[Link]("\ta - Add");
[Link]("\ts - Subtract");
[Link]("\tm - Multiply");
[Link]("\td - Divide");
[Link]("Your option? ");
 string op = [Link]();

try
{
result = [Link](cleanNum1, cleanNum2, op);
if ([Link](result))
{
[Link]("This operation will result in a
mathematical error.\n");
}
else [Link]("Your result: {0:0.##}\n", result);
}
catch (Exception e)
{
[Link]("Oh no! An exception occurred trying to do
the math.\n - Details: " + [Link]);
}

[Link]("------------------------\n");

// Wait for the user to respond before closing.

[Link]("Press 'n' and Enter to close the app, or press
any other key and Enter to continue: ");
if ([Link]() == "n") endApp = true;

[Link]("\n"); // Friendly linespacing.

}
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 • 18/03/2023 • 26 minutos para o fim da leitura

Aplica-se a: Visual Studio Visual Studio para Mac Visual Studio Code

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ê:

＂ 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. Na tela Informações adicionais, o .NET 6.0 está selecionado. Selecione Criar.

O Visual Studio cria o novo projeto e adiciona à solução.

5. Renomeie o arquivo [Link] como [Link]. Para renomear o arquivo,
você pode clicar com o botão direito do mouse no nome no Gerenciador de
Soluções e escolher Renomear, selecionar o nome e pressionar F2 ou selecionar o
nome e clicar novamente para digitar.

Uma mensagem pode perguntar se você deseja renomear todas 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 [Link], selecione a classe Calculator e todo o código e pressione Ctrl+X
para cortá-la. Em seguida, em [Link], cole o código no namespace
CalculatorLibrary .

Adicione também public antes da classe Calculadora para expô-la fora da

biblioteca.

Agora o [Link] deve ser semelhante ao seguinte código:

C#

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

// Use a switch statement to do the math.

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;
}
}
}

9. O [Link] também tem uma referência, mas um erro diz que a chamada
[Link] não foi resolvida. Isso ocorre porque CalculatorLibrary

está em um namespace diferente. Para uma referência totalmente qualificada, você

pode adicionar o namespace CalculatorLibrary à chamada
[Link] :

C#

result = [Link](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 [Link].

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 [Link] e usa classes
[Link] como StreamWriter .

1. Comece adicionando as diretivas using na parte superior de [Link]:

C#

using [Link];

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
[Link].

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 = [Link]("[Link]");
[Link](new TextWriterTraceListener(logFile));
[Link] = true;
[Link]("Starting Calculator Log");
[Link]([Link]("Started {0}",
[Link]()));
}

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#
 public double DoOperation(double num1, double num2, string op)
{
double result = [Link]; // Default value is "not-a-number" if
an operation, such as division, could result in an error.

// Use a switch statement to do the math.

switch (op)
{
case "a":
result = num1 + num2;
[Link]([Link]("{0} + {1} = {2}", num1,
num2, result));
break;
case "s":
result = num1 - num2;
[Link]([Link]("{0} - {1} = {2}", num1,
num2, result));
break;
case "m":
result = num1 * num2;
[Link]([Link]("{0} * {1} = {2}", num1,
num2, result));
break;
case "d":
// Ask the user to enter a non-zero divisor.
if (num2 != 0)
{
result = num1 / num2;
[Link]([Link]("{0} / {1} = {2}", num1,
num2, result));
}
break;
// Return text for an incorrect option entry.
default:
break;
}
return result;
}

4. De volta ao [Link], 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 = [Link](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 [Link]. A saída deve parecer com esta:

Saída

Starting Calculator Log

Started 7/9/2020 [Link] PM
1 + 2 = 3
3 * 3 = 9

Neste ponto, o [Link] deve ser semelhante a este código:

C#

using [Link];

namespace CalculatorLibrary
{
public class Calculator
{

public Calculator()
{
StreamWriter logFile = [Link]("[Link]");
[Link](new TextWriterTraceListener(logFile));
[Link] = true;
[Link]("Starting Calculator Log");
[Link]([Link]("Started {0}",
[Link]()));
}

public double DoOperation(double num1, double num2, string op)

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

// Use a switch statement to do the math.

switch (op)
{
case "a":
result = num1 + num2;
[Link]([Link]("{0} + {1} = {2}", num1,
 num2, result));
break;
case "s":
result = num1 - num2;
[Link]([Link]("{0} - {1} = {2}", num1,
num2, result));
break;
case "m":
result = num1 * num2;
[Link]([Link]("{0} * {1} = {2}", num1,
num2, result));
break;
case "d":
// Ask the user to enter a non-zero divisor.
if (num2 != 0)
{
result = num1 / num2;
[Link]([Link]("{0} / {1} = {2}",
num1, num2, result));
}
break;
// Return text for an incorrect option entry.
default:
break;
}
return result;
}
}
}

O [Link] deve ser como o seguinte código:

C#

using CalculatorLibrary;

namespace CalculatorProgram
{

class Program
{
static void Main(string[] args)
{
bool endApp = false;
// Display title as the C# console calculator app.
[Link]("Console Calculator in C#\r");
[Link]("------------------------\n");

Calculator calculator = new Calculator();

while (!endApp)
{
// Declare variables and set to empty.
string numInput1 = "";
 string numInput2 = "";
double result = 0;

// Ask the user to type the first number.

[Link]("Type a number, and then press Enter: ");
numInput1 = [Link]();

double cleanNum1 = 0;
while ()
{
[Link]("This is not valid input. Please enter an
integer value: ");
numInput1 = [Link]();
}

// Ask the user to type the second number.

[Link]("Type another number, and then press Enter:
");
numInput2 = [Link]();

double cleanNum2 = 0;
while ()
{
[Link]("This is not valid input. Please enter an
integer value: ");
numInput2 = [Link]();
}

// Ask the user to choose an operator.

[Link]("Choose an operator from the following
list:");
[Link]("\ta - Add");
[Link]("\ts - Subtract");
[Link]("\tm - Multiply");
[Link]("\td - Divide");
[Link]("Your option? ");

string op = [Link]();

try
{
result = [Link](cleanNum1, cleanNum2,
op);
if ([Link](result))
{
[Link]("This operation will result in a
mathematical error.\n");
}
else [Link]("Your result: {0:0.##}\n",
result);
}
catch (Exception e)
{
[Link]("Oh no! An exception occurred trying
to do the math.\n - Details: " + [Link]);
 }

[Link]("------------------------\n");

// Wait for the user to respond before closing.

[Link]("Press 'n' and Enter to close the app, or
press any other key and Enter to continue: ");
if ([Link]() == "n") endApp = true;

[Link]("\n"); // Friendly linespacing.

}
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 [Link]. 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 [Link] e selecione Instalar.

 Se for solicitado que você aceite as alterações, selecione OK.

O Visual Studio baixa o pacote e adiciona ao projeto. Uma nova entrada será
exibida no nó Pacotes no Gerenciador de Soluções.

3. Crie o objeto membro JsonWriter e substitua o construtor Calculator pelo

seguinte código:

C#

JsonWriter writer;

public Calculator()
{
StreamWriter logFile = [Link]("[Link]");
[Link] = true;
writer = new JsonTextWriter(logFile);
[Link] = [Link];
[Link]();
[Link]("Operations");
[Link]();
}

4. Modifique o método DoOperation para adicionar o código JSON writer :

C#
 public double DoOperation(double num1, double num2, string op)
{
double result = [Link]; // Default value is "not-a-number"
if an operation, such as division, could result in an error.
[Link]();
[Link]("Operand1");
[Link](num1);
[Link]("Operand2");
[Link](num2);
[Link]("Operation");
// Use a switch statement to do the math.
switch (op)
{
case "a":
result = num1 + num2;
[Link]("Add");
break;
case "s":
result = num1 - num2;
[Link]("Subtract");
break;
case "m":
result = num1 * num2;
[Link]("Multiply");
break;
case "d":
// Ask the user to enter a non-zero divisor.
if (num2 != 0)
{
result = num1 / num2;
}
[Link]("Divide");
break;
// Return text for an incorrect option entry.
default:
break;
}
[Link]("Result");
[Link](result);
[Link]();

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()

{
[Link]();
[Link]();
 [Link]();
}

6. No final de [Link], antes do return; , adicione uma chamada a Finish :

C#

// Add call to close the JSON writer before return

[Link]();
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 [Link] 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 [Link], 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 = [Link](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.

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 [Link] , indicado pelo

ponteiro amarelo. A segunda linha mostra a função que chamou o método, do
método Main em [Link].

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 o aplicativo continuar,
ele gerará uma exceção geral (um erro), mas talvez você queira tentar outra coisa,
como exibir 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#

result = num1 / num2;

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 [Link], depois de concluir todas
as etapas:

C#

using [Link];

namespace CalculatorLibrary
{
 public class Calculator
{

JsonWriter writer;

public Calculator()
{
StreamWriter logFile = [Link]("[Link]");
[Link] = true;
writer = new JsonTextWriter(logFile);
[Link] = [Link];
[Link]();
[Link]("Operations");
[Link]();
}

public double DoOperation(double num1, double num2, string op)

{
double result = [Link]; // Default value is "not-a-number"
if an operation, such as division, could result in an error.
[Link]();
[Link]("Operand1");
[Link](num1);
[Link]("Operand2");
[Link](num2);
[Link]("Operation");
// Use a switch statement to do the math.
switch (op)
{
case "a":
result = num1 + num2;
[Link]("Add");
break;
case "s":
result = num1 - num2;
[Link]("Subtract");
break;
case "m":
result = num1 * num2;
[Link]("Multiply");
break;
case "d":
// Ask the user to enter a non-zero divisor.
if (num2 != 0)
{
result = num1 / num2;
}
[Link]("Divide");
break;
// Return text for an incorrect option entry.
default:
break;
}
[Link]("Result");
[Link](result);
 [Link]();

return result;
}

public void Finish()

{
[Link]();
[Link]();
[Link]();
}
}
}

E este é o código para [Link]:

C#

using CalculatorLibrary;

namespace CalculatorProgram
{

class Program
{
static void Main(string[] args)
{
bool endApp = false;
// Display title as the C# console calculator app.
[Link]("Console Calculator in C#\r");
[Link]("------------------------\n");

Calculator calculator = new Calculator();

while (!endApp)
{
// Declare variables and set to empty.
string numInput1 = "";
string numInput2 = "";
double result = 0;

// Ask the user to type the first number.

[Link]("Type a number, and then press Enter: ");
numInput1 = [Link]();

double cleanNum1 = 0;
while ()
{
[Link]("This is not valid input. Please enter an
integer value: ");
numInput1 = [Link]();
}

// Ask the user to type the second number.

 [Link]("Type another number, and then press Enter:
");
numInput2 = [Link]();

double cleanNum2 = 0;
while ()
{
[Link]("This is not valid input. Please enter an
integer value: ");
numInput2 = [Link]();
}

// Ask the user to choose an operator.

[Link]("Choose an operator from the following
list:");
[Link]("\ta - Add");
[Link]("\ts - Subtract");
[Link]("\tm - Multiply");
[Link]("\td - Divide");
[Link]("Your option? ");

string op = [Link]();

try
{
result = [Link](cleanNum1, cleanNum2,
op);
if ([Link](result))
{
[Link]("This operation will result in a
mathematical error.\n");
}
else [Link]("Your result: {0:0.##}\n",
result);
}
catch (Exception e)
{
[Link]("Oh no! An exception occurred trying
to do the math.\n - Details: " + [Link]);
}

[Link]("------------------------\n");

// Wait for the user to respond before closing.

[Link]("Press 'n' and Enter to close the app, or
press any other key and Enter to continue: ");
if ([Link]() == "n") endApp = true;

[Link]("\n"); // Friendly linespacing.

}
[Link]();
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 [Link] 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 [Link]
Core no Visual Studio
Artigo • 20/03/2023 • 11 minutos para o fim da leitura

Aplica-se a: Visual Studio Visual Studio para Mac Visual Studio Code

Neste tutorial para desenvolvimento C# com o [Link] Core, você criará um aplicativo
Web C# [Link] Core no Visual Studio.

Este tutorial mostrará como:

＂ Criar um projeto do Visual Studio

＂ Criar um aplicativo Web C# [Link] 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ê criará um projeto [Link] Core. O tipo de projeto vem com todos os
arquivos de modelo necessários para compilar um site totalmente funcional.

1. Na janela inicial, selecione Criar um novo projeto.

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 [Link] Core e, em seguida, Avançar.

７ Observação
 Se não vir o modelo Aplicativo Web [Link] Core, você poderá instalá-lo da
janela Criar um novo projeto. Na mensagem Não encontrou o que você
procura?, localizada na parte inferior da lista de modelos, selecione o link
Instalar mais ferramentas e recursos.

Em seguida, no Instalador do Visual Studio, selecione a carga de trabalho do

[Link] e desenvolvimento Web.

Selecione o botão Modificar no Instalador do Visual Studio. Pode ser

necessário salvar o trabalho. Nesse caso, execute essa ação. Em seguida,
selecione Continuar para instalar a carga de trabalho.

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 6.0 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:

None. Sem autenticação.

Contas individuais. Esses 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 Active Directory,
Azure AD ou Microsoft 365 para autenticação.
Windows. Adequada para aplicativos da intranet.

Deixe a caixa Habilitar Docker desmarcada e selecione Nenhum em Tipo de

Autenticação. Em seguida, selecione Criar.

O Visual Studio abrirá 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 [Link] 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 [Link] e exiba 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ó [Link] no Gerenciador de Soluções e
selecione o arquivo [Link].

5. Visualize o arquivo [Link] no editor de código.

6. O projeto também contém a pasta wwwroot que é a raiz do site. Expanda a pasta
para exibir seu conteúdo.

Você pode colocar o conteúdo do site estático, como CSS, imagens e bibliotecas
JavaScript, diretamente nos caminhos em que deseja.

7. O projeto também contém os arquivos de configuração que gerenciam o

aplicativo web no tempo de execução. A configuração de aplicativo padrão é
armazenada em [Link]. No entanto, você pode substituir essas
configurações usando [Link]. Expanda o arquivo
[Link] para exibir o arquivo [Link].
Executar, depurar e fazer alterações
1. Selecione o botão IIS Express na barra de ferramentas 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 isso 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 [Link].
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 [Link] 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 [Link]. Em

seguida, limpe as diretivas using na parte superior do arquivo selecionando o
seguinte atalho:

Diretiva mouseover or select a greyed out using . A lâmpada Ações Rápidas será
exibida logo abaixo do sinal de interpolação ou na margem esquerda. Selecione o
ícone de lâmpada e a seta de expansão ao lado de Remover usos desnecessários.
 Agora, selecione Visualizar alterações para ver o que mudará.

Escolha Aplicar. O Visual Studio exclui as diretivas using desnecessárias do

arquivo.

7. Em seguida, crie uma cadeia de caracteres para a data atual formatada para sua
cultura ou região usando o método [Link].

O primeiro argumento para o método especifica como a data deve ser

exibida. Este exemplo usa o especificador de formato ( d ) que indica o
 formato de data abreviada.
O segundo argumento é o objeto CultureInfo que especifica a cultura ou a
região da data. O segundo argumento determina, entre outras coisas, o
idioma de qualquer palavra na data e o tipo de separadores usados.

Altere o corpo do método OnGet() para o código a seguir:

C#

public void OnGet()

{
string dateTime = [Link]("d", new CultureInfo("en-
US"));
ViewData["TimeStamp"] = dateTime;
}

8. Observe que a seguinte diretiva using é adicionada automaticamente à parte

superior do arquivo:

C#

using [Link];

[Link] contém a classe CultureInfo.

9. Pressione F5 para abrir seu projeto no navegador da Web.

10. Na parte superior do site, selecione Privacidade para ver as alterações.

11. 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
[Link].

O arquivo [Link] 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 exibido na 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 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 [Link] Core e o IDE do Visual Studio. Para saber mais sobre como criar
um aplicativo Web ou site com C# e [Link], continue com o tutorial a seguir:

Criar um aplicativo Web Páginas Razor com o [Link] 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 • 03/03/2023 • 5 minutos para o fim da leitura

Aplica-se a: Visual Studio Visual Studio para Mac Visual Studio Code

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.

Se você ainda não tiver instalado o Visual Studio, acesse a página Downloads do Visual
Studio para instalá-lo gratuitamente.

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!

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 [Link] 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 [Link], 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 = [Link]
 };
await [Link]();
}

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 [Link] , 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 • 21/03/2023 • 6 minutos para o fim da leitura

Aplica-se a: Visual Studio Visual Studio para Mac Visual Studio Code

７ 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#.

Se você ainda não tiver instalado o Visual Studio, acesse a página Downloads do Visual
Studio para instalá-lo gratuitamente.

Criar um projeto
Primeiro, crie um projeto da Plataforma Universal do Windows. O tipo de projeto vem
com todos os arquivos de modelo que você precisa, antes mesmo de você adicionar
alguma coisa!

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 [Link] 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. Selecione o ícone Fixar para encaixar a janela Caixa de Ferramentas.

4. Selecione o 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 [Link], 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
[Link]();
[Link] stream =
await [Link]("Hello, World!");
[Link](stream, [Link]);
[Link]();
}

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 [Link].)

Executar o aplicativo
É 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 esta imagem:

3. Selecione o botão Olá, Mundo.

Seu dispositivo Windows 10 ou posterior dirá literalmente "Olá, Mundo!".

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 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 • 18/03/2023 • 15 minutos para o fim da leitura

Aplica-se a: Visual Studio Visual Studio para Mac Visual Studio Code

Ao concluir este tutorial, você estará familiarizado com vários designers, ferramentas e
caixas de diálogo que poderão ser usados no desenvolvimento de aplicativos com o
Visual Studio. Você vai criar um aplicativo "Olá, Mundo", projetar a interface do usuário,
adicionar código e depurar erros enquanto aprende sobre o trabalho no IDE (ambiente
de desenvolvimento integrado).

Pré-requisitos
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 isso 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 [Link] 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ê verá as janelas
de ferramentas, os menus e as barras de ferramentas, além do espaço da janela
principal. 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ê passará a maior parte do seu tempo nessa área central.

Criar o projeto
Ao criar um aplicativo no Visual Studio, você cria primeiro um projeto e uma solução.
Para este exemplo, você criará um projeto do WPF (Windows Presentation Foundation).

1. Abra o Visual Studio.

2. Na tela Iniciar, selecione Criar um novo 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 6.0 (suporte de longo prazo) já deve

estar selecionado para sua estrutura de destino. Caso contrário, selecione .NET 6.0
(suporte de longo prazo). 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 [Link] 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 [Link] e pressione Shift+F7 para
abrir o designer.

Adicionaremos três tipos de controles a este aplicativo: um controle TextBlock, dois

controles RadioButton e um controle Button.

Adicionar um controle TextBlock

1. Pressione Ctrl+Q para ativar a caixa de pesquisa e 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. Você pode usar as diretrizes para
centralizar o controle.

Sua janela deve se parecer com a seguinte imagem:

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>
<TextBlock HorizontalAlignment="Left" Margin="387,60,0,0"
TextWrapping="Wrap" Text="Select a message option and then choose the
Display button." VerticalAlignment="Top"/>
</Grid>

2. Se necessário, centralize novamente o TextBlock e salve as alterações pressionando

Ctrl+S ou usando o item de menu Arquivo.

Em seguida, você adicionará dois controles RadioButton ao formulário.

Adicionar botões de opção

1. Na Caixa de Ferramentas, localize o controle RadioButton.

2. Adicione dois controles RadioButton à superfície de design escolhendo o item

RadioButton e arrastando-o para a janela na superfície de design. Mova os botões
(selecionando-os e usando as teclas de direção) para que os botões sejam exibidos
lado a lado sob o controle TextBlock. Você pode usar as diretrizes para alinhar os
controles.

A sua janela deve se parecer com esta:

 3. Na janela Propriedades do controle RadioButton esquerdo, altere a propriedade
Nome (a propriedade na parte superior da janela Propriedades) para HelloButton .

4. Na janela Propriedades do controle RadioButton direito, altere a propriedade

Name para GoodbyeButton e, em seguida, salve as alterações.

Em seguida, adicione o texto de exibição para cada controle RadioButton. O

procedimento a seguir atualiza a propriedade Conteúdo de um controle RadioButton.

Adicionar o texto de exibição de cada botão de opção

 1. Atualize o atributo Content para HelloButton e GoodbyeButton para "Hello" e
"Goodbye" no XAML. A marcação XAML deve agora ser semelhante ao exemplo a
seguir:

XAML

<Grid>
<TextBlock HorizontalAlignment="Left" Margin="252,47,0,0"
TextWrapping="Wrap" Text="Select a message option and then choose the
Display button." VerticalAlignment="Top"/>
<RadioButton x:Name="HelloButton" Content="Hello"
HorizontalAlignment="Left" Margin="297,161,0,0"
VerticalAlignment="Top"/>
<RadioButton x:Name="GoodbyeButton" Content="Goodbye"
HorizontalAlignment="Left" Margin="488,161,0,0"
VerticalAlignment="Top"/>
</Grid>

Definir que um botão de opção faça check-in por padrão

Nesta etapa, definiremos que o HelloButton permaneça marcado por padrão, de
maneira que um dos dois botões de opção esteja sempre selecionado.

1. Na exibição XAML, localize a marcação HelloButton.

2. Adicione um atributo IsChecked e configure-o como True. Especificamente,

adicione IsChecked="True" .

A marcação XAML deve agora ser semelhante ao exemplo a seguir:

XAML

<Grid>
<TextBlock HorizontalAlignment="Left" Margin="252,47,0,0"
TextWrapping="Wrap" Text="Select a message option and then choose the
Display button." VerticalAlignment="Top"/>
<RadioButton x:Name="HelloButton" Content="Hello" IsChecked="True"
HorizontalAlignment="Left" Margin="297,161,0,0"
VerticalAlignment="Top"/>
<RadioButton x:Name="GoodbyeButton" Content="Goodbye"
HorizontalAlignment="Left" Margin="488,161,0,0"
VerticalAlignment="Top"/>
</Grid>

O elemento final da interface do usuário que você adicionará é um controle de Botão.

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. As diretrizes podem 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 captura de tela a seguir.

A marcação XAML deve agora ser semelhante ao exemplo a seguir:

XAML

<Grid>
<TextBlock HorizontalAlignment="Left" Margin="252,47,0,0"
TextWrapping="Wrap" Text="Select a message option and then choose the
Display button." VerticalAlignment="Top"/>
<RadioButton x:Name="HelloButton" Content="Hello" IsChecked="True"
HorizontalAlignment="Left" Margin="297,161,0,0"
VerticalAlignment="Top"/>
<RadioButton x:Name="GoodbyeButton" Content="Goodbye"
HorizontalAlignment="Left" Margin="488,161,0,0"
VerticalAlignment="Top"/>
<Button Content="Display" HorizontalAlignment="Left"
Margin="377,270,0,0" VerticalAlignment="Top" Width="75"/>
</Grid>

Adicionar um código ao botão de exibição

Quando esse aplicativo é executado, uma caixa de mensagem é exibida depois que um
usuário escolhe um botão de opção e, em seguida, escolhe o botão Exibir. Uma caixa de
mensagem será exibida para Olá e outra para Até logo. Para criar esse comportamento,
adicione um código ao evento Button_Click em [Link].

1. Na superfície de design, clique duas vezes no botão Exibição.

[Link] é 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 ([Link] == true)
{
[Link]("Hello.");
}
else if ([Link] == true)
{
[Link]("Goodbye.");
}

3. Salve o aplicativo.

Depurar e testar o aplicativo

Em seguida, você depurará o aplicativo para procurar erros e testar se ambas as caixas
de mensagem são exibidas corretamente. As instruções a seguir descrevem como criar e
iniciar o depurador, mas, posteriormente, leia Compilar um aplicativo WPF (WPF) e
Depurar o WPF para obter mais informações.

Alterar o nome de [Link]

Vamos dar um nome mais específico para MainWindow. Em Gerenciador de Soluções,
clique com o botão direito do mouse em [Link] e escolha Renomear.
Renomeie o arquivo para [Link].
Localizar e corrigir erros
Nesta etapa, você encontrará o erro que causamos anteriormente alterando o nome do
arquivo [Link].

Iniciar a depuração e localizar o erro

1. Inicie o depurador pressionando F5 ou selecionando Depurar e depois Iniciar

Depuração.

Uma janela de Modo de Interrupção é exibida e a janela Saída indica que houve
uma IOException: não é possível localizar o recurso '[Link]'.

2. Interrompa o depurador escolhendo Depurador>Interromper a Depuração.

Renomeamos o [Link] como [Link] no início deste tutorial, mas o

código ainda se refere a [Link] como o URI de inicialização do aplicativo.
Portanto, o projeto não pode ser iniciado.

Especificar [Link] como o URI de inicialização

1. No Gerenciador de Soluções, abra o arquivo [Link].

2. Altere StartupUri="[Link]" para StartupUri="[Link]" e salve as

alterações.

Como uma etapa opcional para evitar confusão, altere o título da janela do aplicativo
para corresponder a esse novo nome.

1. No Gerenciador de Soluções, abra o arquivo [Link] que você acabou de

renomear.
 2. Altere o valor da propriedade [Link] de Title="MainWindow" para
Title="Greetings" e salve as alterações.

Inicie o depurador novamente (pressione F5). Você agora deverá ver a janela Greetings
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 [Link] e selecione a seguinte linha: [Link]("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: [Link]("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 [Link]("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 [Link]("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
Criar um aplicativo do Windows Forms
no Visual Studio com C#
Artigo • 17/03/2023 • 7 minutos para o fim da leitura

Aplica-se a: Visual Studio Visual Studio para Mac Visual Studio Code

Neste tutorial, você criará um aplicativo simples do C# que tem uma interface do
usuário baseada em Windows.

Se você ainda não tiver instalado o Visual Studio, acesse a página Downloads do Visual
Studio 2022 para instalá-lo gratuitamente.

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.

1. Abra o Visual Studio.

2. Na janela inicial, selecione Criar um novo projeto.

3. Na janela Criar um novo projeto, selecione 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, selecione C# na lista Linguagem e selecione 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?, selecione o link Instalar mais
ferramentas e recursos.

Em seguida, no Instalador do Visual Studio, selecione a carga de trabalho

Desenvolvimento de desktop do .NET.

Depois disso, selecione o botão Modificar no Instalador do Visual Studio.

Pode ser solicitado que você salve seu trabalho; nesse caso, faça isso. Em
 seguida, selecione 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, selecione Criar.

O Visual Studio abre seu novo projeto.

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. Selecione 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. Expanda Controles Comuns e selecione o ícone Fixar para encaixar a janela Caixa
de Ferramentas.

3. Selecione 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, selecione 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 [Link] [Design], clique duas vezes no botão Clique aqui para abrir a
janela [Link].
 (Como alternativa, você pode expandir [Link] no Gerenciador de Soluções e,
em seguida, escolher Form1.)

2. Na janela [Link], após a linha private void, digite ou insira [Link] =

"Hello World!"; conforme mostrado na captura de tela a seguir:

Executar o aplicativo
1. Selecione 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. Ele incluirá seu botão Clique aqui e o texto
label1.

2. Selecione 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 visualizador de
imagens Windows Forms aplicativo no
Visual Studio
Artigo • 27/09/2022 • 6 minutos para o fim da leitura

Aplica-se a: Visual Studio Visual Studio para Mac Visual Studio Code

Nesta série de três tutoriais, você criará um aplicativo 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 Windows Forms

＂ Adicionar um elemento layout
＂ Execute seu aplicativo.

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.

Criar seu projeto Windows Forms

Quando você cria um visualizador de imagens, a primeira etapa é criar um projeto de
aplicativo Windows Forms.

1. Abra o Visual Studio.

2. Na janela inicial, selecione Criar um novo projeto.

3. Na janela Criar um novo projeto, pesquise Windows Forms. Em seguida, selecione
Área de Trabalho na lista de tipos de projeto .

4. Selecione o modelo Windows Forms App (.NET Framework) para C# ou Visual

Basic e selecione Avançar.

７ Observação
 Se você não vir o modelo Windows Forms App (.NET Framework), poderá
instalá-lo na janela Criar um novo projeto. Na mensagem Não localizar o que
você está procurando? Selecione o link Instalar mais ferramentas e recursos .

Em seguida, em Instalador do Visual Studio, selecione desenvolvimento da

área de trabalho do .NET.

Selecione Modificar no Instalador do Visual Studio. Você pode ser solicitado a

salvar seu trabalho. Em seguida, selecione Continuar a instalar a carga de
trabalho.

5. Na janela Configurar seu novo projeto , nomeie seu projeto PictureViewer e

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 para seu aplicativo.

Neste ponto, o Visual Studio exibe um formulário vazio no Designer de Formulários do

Windows.

Adicionar um elemento layout

Seu aplicativo de exibição de imagens contém uma caixa de seleção, uma caixa de
seleção e quatro botões, que você adicionará no próximo tutorial. O elemento layout
controla sua localização no formulário. Esta seção mostra como alterar o título do
formulário, redimensionar o formulário e adicionar um elemento de layout.

1. Em seu projeto, selecione o designer de Windows Forms. A guia lê [Link]

[Design] para C# ou [Link] [Design] para Visual Basic.

2. Selecione em qualquer lugar no Form1.

3. A janela Propriedades agora exibe as propriedades do formulário. A janela

Propriedades geralmente está no canto inferior direito do Visual Studio. Esta seção
 controla várias propriedades, como cor de primeiro plano e plano de fundo, texto
de título que aparece na parte superior do formulário e o tamanho do formulário.

Se você não vir Propriedades, selecione Exibir>Janela Propriedades.

4. Localize a propriedade Text na janela Propriedades . Dependendo de como a lista

estiver classificada, talvez seja necessário rolar para baixo. Insira o valor
Visualizador de Imagens e, em seguida, escolha Enter.

Seu formulário agora tem o visualizador de imagens de texto na barra de título.

７ Observação

Você pode exibir 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 o identificador de arrastar no canto

inferior direito do formulário. O identificador é um pequeno quadrado branco 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 você não vir, 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

Depois de adicionar o TableLayoutPanel, se uma janela aparecer dentro do

formulário com o título Tarefas TableLayoutPanel, clique em qualquer lugar
dentro do formulário para fechá-lo.

9. Selecione TableLayoutPanel. Você pode verificar qual controle está selecionado

examinando a janela Propriedades .
10. Com o TableLayoutPanel selecionado, localize a propriedade Dock , que tem o
valor None. Selecione a seta suspensa e, em seguida, selecione Preencher, que é o
botão grande no meio do menu suspenso.

O encaixe refere-se a como uma janela é anexada a outra janela ou área.

O 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 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. Na caixa de diálogo 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.

Seu TableLayoutPanel agora tem uma linha superior grande, uma linha inferior
pequena, uma coluna esquerda pequena e uma coluna grande à direita.

Seu layout está concluído.

 ７ Observação

Antes de executar seu aplicativo, salve seu aplicativo escolhendo o botão Salvar
Todas as ferramentas. Como alternativa, para salvar seu aplicativo, escolha
Salvar>Arquivo Tudo na barra de menus ou pressione Ctrl+Shift+S. É uma prática
recomendada salvar no início e com frequência.

Executar o aplicativo
Ao criar um projeto de aplicativo Windows Forms, você cria um programa que é
executado. Nesta fase, seu aplicativo Visualizador de Imagens não faz muito. Por
enquanto, ele exibe uma janela vazia que mostra o 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 chave 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.

Examine a barra de ferramentas do IDE do Visual Studio. Mais botões aparecem na

barra de ferramentas quando você executa um aplicativo. Esses botões permitem
que você faça coisas como parar e iniciar seu aplicativo e ajudá-lo a rastrear
quaisquer erros.
 2. Use um dos seguintes métodos para interromper 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 de dentro do IDE do Visual Studio, ele é
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.

Tutorial parte 2: 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 • 27/09/2022 • 5 minutos para o fim da leitura

Aplica-se a: Visual Studio Visual Studio para Mac Visual Studio Code

Nesta série de três tutoriais, você criará um aplicativo Windows Forms que carrega uma
imagem e a exibe. O IDE (Ambiente de Design Integrado) Visual Studio fornece as
ferramentas necessárias para criar o aplicativo. Para saber mais, confira Bem-vindo ao
IDE 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á a:

＂ Adicionar controles ao seu aplicativo

＂ Adicionar botões em um painel de layout
＂ Alterar nomes e locais de controle
＂ Adicionar componentes de caixa de diálogo

Pré-requisitos
Este tutorial baseia-se no tutorial anterior, Criar um aplicativo visualizador de imagens.
Se você ainda não fez esse tutorial, passe por esse 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 Visual Studio.

1. Abra o Visual Studio. Seu projeto visualizador de imagens aparece em Abrir

recentemente.
 2. No designer de Windows Forms, selecione o TableLayoutPanel que você
adicionou no tutorial anterior. Verifique se tableLayoutPanel1 aparece na janela
Propriedades .

3. No lado esquerdo do IDE Visual Studio, selecione a guia Caixa de Ferramentas. Se

você não vir, selecione Exibir>Caixa de Ferramentas na barra de menus ou
Ctrl+Alt+X. Na caixa de ferramentas, expanda Controles Comuns.

4. Clique duas vezes em PictureBox para adicionar um controle PictureBox ao

formulário. Visual Studio IDE adiciona o controle PictureBox à primeira célula vazia
do TableLayoutPanel.

5. Escolha o novo controle PictureBox para selecioná-lo e selecione o triângulo preto

no novo controle PictureBox para exibir sua lista de tarefas.

6. Selecione Encaixe no Contêiner Pai, que define a propriedade PictureBox Dock

como Fill. Você pode ver esse valor na janela Propriedades .

7. Na janela Propriedades do 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 Windows Forms, selecione 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 no
TableLayoutPanel, de modo que o controle CheckBox é adicionado à célula inferior
esquerda.

10. Escolha a propriedade Texto e insira Stretch.

Adicionar botões em um painel de layout
Os controles até agora foram adicionados ao TableLayoutPanel. Essas etapas mostram
como adicionar quatro botões a um novo painel de layout no TableLayoutPanel.

1. Selecione o TableLayoutPanel no formulário. Abra a Caixa de Ferramentas,

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 como Fill. Você pode definir essa
propriedade selecionando o triângulo preto e selecionando Dock 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 e 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 no Botão novamente para adicionar outro botão. O IDE chama o
próximo botão2.

5. Adicione mais dois botões dessa forma. Outra opção é selecionar o botão2 e, em
seguida, selecionar Editar>Cópia 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 o botão3 e o botão4
ao FlowLayoutPanel.

6. Selecione o primeiro botão e defina sua propriedade Text para mostrar uma
imagem.

7. Defina as propriedades de Texto dos próximos três botões para limpar a imagem,
definir a cor da tela de fundo e Fechar.

8. Para dimensionar os botões e organizá-los, selecione o FlowLayoutPanel. Defina a

propriedade FlowDirection como RightToLeft.

Os botões devem se alinhar ao lado direito da célula e reverter a ordem para que o
botão Mostrar uma imagem esteja à 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 ajustar o 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
adicionados ainda não fazem nada.

Alterar nomes de controle

Há quatro botões em seu formulário, chamados button1, button2, button3 e button4
em C#. Em Visual Basic, a primeira letra padrão de qualquer nome de controle é
maiúscula, portanto, os botões são chamados Button1, Button2, Button3 e Button4.
Use estas 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, escolha Esc para cancelar a seleção.

2. Na janela Propriedades , procure (Nome). Altere o nome para closeButton.

O IDE não aceita nomes que contêm 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 caixa de diálogo

Seu aplicativo pode abrir arquivos de imagem e escolher uma cor de tela de fundo
usando componentes. Um componente é como um controle. Você usa a Caixa de
Ferramentas para adicionar um componente ao formulário. Você define suas
propriedades 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 OpenFileDialog componente e um ColorDialog

componente ao formulário.

1. Selecione o designer de Windows Forms ([Link] [Design]). Em seguida, abra a

Caixa de Ferramentas e selecione o grupo Diálogos .

2. Clique duas vezes em OpenFileDialog para adicionar um componente chamado

openFileDialog1 ao formulário.

3. Clique duas vezes em ColorDialog para adicionar um componente chamado

colorDialog1. Os componentes aparecem na parte inferior do designer de
Windows Forms como ícones.

4. Escolha o ícone openFileDialog1 e defina duas propriedades:

Defina a propriedade Filter como a 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 Filter especificam os tipos que a caixa de diálogo

Selecionar uma imagem exibe.

Próximas etapas
Avance para o próximo tutorial para saber como adicionar código ao seu aplicativo.

Tutorial parte 3: Adicionar código ao Visualizador de Imagens

Tutorial: Adicionar código ao aplicativo
visualizador de imagens do Windows
Forms no Visual Studio
Artigo • 21/03/2023 • 8 minutos para o fim da leitura

Aplica-se a: Visual Studio Visual Studio para Mac Visual Studio Code

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(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 [Link]. Se você estiver usando o Visual Basic, a guia será
denominada [Link].

Essa guia exibe o arquivo de código por trás do formulário.

７ Observação

Sua guia [Link] 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 [Link]() .

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 ([Link]() == [Link])

Para o Visual Basic, deve ser o seguinte.

If [Link]() = [Link] Then

11. Adicione a linha de código a seguir.

 C#

C#

[Link]([Link]);

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#

private void showButton_Click(object sender, EventArgs e)

{
if ([Link]() == [Link])
{
[Link]([Link]);
}
}

1. Adicione o seguinte comentário ao seu código.

C#

C#

private void showButton_Click(object sender, EventArgs e)

{
// Show the Open File dialog. If the user clicks OK, load the
// picture that the user chose.
if ([Link]() == [Link])
{
[Link]([Link]);
}
}

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.
[Link] = 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 ([Link]() == [Link])
[Link] = [Link];
}

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.
[Link]();
}

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 ([Link])
[Link] = [Link];
else
[Link] = [Link];
}

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.
Na barra de ferramentas, selecione o botão Iniciar.

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 • 27/09/2022 • 8 minutos para o fim da leitura

Aplica-se a: Visual Studio Visual Studio para Mac Visual Studio Code

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 tenta responder
dentro de 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, consulte
Bem-vindo ao IDE do Visual Studio.

Neste primeiro tutorial, você aprenderá a:

＂ Crie um projeto do Visual Studio que use 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
Você precisa do Visual Studio para concluir este tutorial. Visite a página de downloads
do Visual Studio para obter uma versão gratuita.

Criar seu projeto de Windows Forms

Quando você cria um teste de matemática, a primeira etapa é criar um projeto de
aplicativo Windows Forms.

1. Abra o Visual Studio.

2. Na janela inicial, selecione Criar um novo projeto.

3. Na janela Criar um novo projeto, pesquise Windows Forms. Em seguida, selecione
Área de Trabalho na lista de tipos do Projeto .

4. Selecione o modelo Windows Forms App (.NET Framework) para C# ou Visual

Basic e selecione Avançar.

７ Observação
 Se você não vir o modelo do aplicativo Windows Forms (.NET Framework),
poderá instalá-lo na janela Criar um novo projeto. Na mensagem Não
encontrar o que você está procurando? Selecione Instalar mais ferramentas
e recursos.

Em seguida, em Instalador do Visual Studio, selecione desenvolvimento da

área de trabalho do .NET.

Selecione Modificar em Instalador do Visual Studio. Você pode ser solicitado

a salvar seu trabalho. Em seguida, selecione Continuar para instalar a carga de
trabalho.

5. Na janela Configurar seu novo projeto , nomeie seu projeto MathQuiz e selecione
Criar.

O Visual Studio cria uma solução para seu aplicativo. Uma solução é um contêiner para
todos os projetos e arquivos de que seu aplicativo precisa.

Definir propriedades do formulário

Depois de selecionar seu modelo e nomear seu arquivo, o Visual Studio abrirá um
formulário para você. Esta seção mostra como alterar algumas propriedades do
formulário.

1. Em seu projeto, selecione Windows Forms Designer. A guia designer é rotulada

[Link] [Design] para C# ou [Link] [Design] para Visual Basic.

2. Selecione o formulário, Formulário1.

3. A janela Propriedades agora exibe as propriedades do formulário. Essa janela

geralmente está no canto inferior direito do Visual Studio. Se você não vir
Propriedades, selecione Exibir>Janela Propriedades.

4. Localize a propriedade Text na janela Propriedades . Dependendo de como a lista

estiver classificada, talvez seja necessário rolar para baixo. Insira o valor Teste de
 Matemática para o valor de Texto e selecione Enter.

Seu formulário agora tem o texto "Teste de Matemática" na barra de título.

７ Observação

Você pode exibir 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 o

identificador até que o tamanho correto apareça como o valor Tamanho na janela
Propriedades . O identificador de arrastar é um pequeno quadrado branco no
canto inferior direito do formulário. Você também pode redimensionar o
formulário alterando os valores da propriedade Size .

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 de 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. Esta seção mostra como usar um
rótulo para essa caixa. Você adicionará código para o temporizador de contagem
regressiva em um tutorial posterior nesta série.

1. No lado esquerdo do IDE do Visual Studio, selecione a guia Caixa de Ferramentas .

Se você não vir a caixa de ferramentas, selecione Exibir>Caixa de Ferramentas na
barra de menus ou Ctrl+Alt+X.

2. Selecione o Label controle 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 o Dimensionamento Automático para False para que você possa
redimensionar a caixa.
Altere o BorderStyle para FixedSingle para desenhar uma linha ao redor da
caixa.
Defina o Tamanho como 200, 30.
 Selecione a propriedade Texto e, em seguida, selecione a chave de
Backspace para limpar o valor de Texto .
Selecione o sinal de adição (+) ao lado da propriedade Fonte e defina o
Tamanho 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 deste rótulo como Time Left.

7. Mova o rótulo para que ele se alinha à esquerda do rótulo timeLabel .

Adicionar controles para o problema 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 Label 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).

Definir o Dimensionamento Automático como False.
Defina o Tamanho como 60, 50.
Defina o tamanho da fonte como 18.
Defina TextAlign como MiddleCenter.
Defina o Local como 50, 75 para posicionar o controle no formulário.
Defina o (Nome) como plusLeftLabel.

3. No formulário, selecione o rótulo plusLeftLabel que você criou. Copie o rótulo

selecionando Editar>Cópia 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 adição).

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 NumericUpDown controle 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 o tamanho da fonte como 18.

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 problemas de

subtração, multiplicação e 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 se alinhar abaixo dos controles de adição.

3. Na caixa Propriedades , defina as seguintes propriedades para os novos controles:

 Defina o (Nome) do primeiro rótulo de ponto de interrogação como
menosLeftLabel.
Defina o Texto do segundo rótulo como - (sinal de menos).
Defina o (Nome) do segundo rótulo de ponto de interrogação como
minusRightLabel.
Defina o (Nome) do controle NumericUpDown como diferença.

4. Copie os controles de adição e cole-os mais duas vezes no formulário.

5. Para a terceira linha:

Defina o (Nome) do primeiro rótulo de ponto de interrogação como

timesLeftLabel.
Defina o Texto do segundo rótulo como × (sinal de multiplicação). Você pode
copiar o sinal de multiplicação deste tutorial e colá-lo no formulário.
Defina o (Nome) do segundo rótulo de ponto de interrogação como
timesRightLabel.
Defina o (Nome) do controle NumericUpDown como produto.

6. Para a quarta linha:

Defina o (Nome) do primeiro rótulo de ponto de interrogação como

dividedLeftLabel.
Defina o Texto do segundo rótulo como ÷ (sinal de divisão). Você pode
copiar o sinal de divisão deste tutorial e colá-lo no formulário.
Defina o (Nome) do segundo rótulo de ponto de interrogação como
dividedRightLabel.
Defina o (Nome) do controle NumericUpDown como quociente.
Adicionar um botão iniciar e definir a ordem
tab-index
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 se
move de um controle para o outro usando a tecla Tab .

1. Adicione um Button controle da Caixa de Ferramentas ao formulário.

2. Na caixa Propriedades , defina as seguintes propriedades do Botão:

Defina o (Nome) como startButton.

Defina o texto para iniciar o teste.
Defina o tamanho da fonte como 14.
Defina AutoSize como True, o que faz com que o botão redimensione
automaticamente para ajustar o texto.
Defina o 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 o TabIndex do controle soma NumericUpDown como 1.

Defina o TabIndex da diferença do controle NumericUpDown como 2.
Defina o TabIndex do controle NumericUpDown do produto como 3.
Defina o TabIndex do controle NumericUpDown quociente como 4.

Executar o aplicativo
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 Salvar>Todos.
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.
Na barra de ferramentas, selecione o botão Iniciar .
 3. Selecione a tecla Tab algumas vezes para ver como o foco se move de um controle
para o outro.

Próximas etapas
Avance para o próximo tutorial para adicionar problemas matemáticos aleatórios e um
manipulador de eventos ao teste de matemática.

Tutorial parte 2: Adicionar problemas matemáticos a um aplicativo WinForms de

teste de matemática
Tutorial: Adicionar problemas
matemáticos a um aplicativo WinForms
de teste de matemática
Artigo • 21/03/2023 • 9 minutos para o fim da leitura

Aplica-se a: Visual Studio Visual Studio para Mac Visual Studio Code

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.

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.

Neste segundo tutorial, você aprenderá como:

＂ 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. [Link] ou [Link] 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

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.

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#

// Create a Random object called randomizer

// to generate random numbers.
Random randomizer = new Random();

// 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 = [Link](51);
addend2 = [Link](51);

// Convert the two randomly generated numbers

// into strings so that they can be displayed
// in the label controls.
[Link] = [Link]();
 [Link] = [Link]();

// 'sum' is the name of the NumericUpDown control.

// This step makes sure its value is zero before
// adding any values to it.
[Link] = 0;
}

Quando você usa o método Next() com um objeto rRandom, como quando você
chama [Link](51) , você obtém um número aleatório que é menor que 51, ou
entre 0 e 50. Esse código chama [Link](51) para que os dois números
aleatórios adicionem uma resposta entre 0 e 100.

Confira de perto estas instruções.

C#

C#

[Link] = [Link]();
[Link] = [Link]();

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#
 public partial class Form1 : Form
{
// Create a Random object called randomizer
// to generate random numbers.
Random randomizer = new Random();

// These integer variables store the numbers

// for the addition problem.
int addend1;
int addend2;

// These integer variables store the numbers

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

// These integer variables store the numbers

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

// These integer variables store the numbers

// 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>
public void StartTheQuiz()
{
// Fill in the addition problem.
// Generate two random numbers to add.
// Store the values in the variables 'addend1' and 'addend2'.
addend1 = [Link](51);
addend2 = [Link](51);

// Convert the two randomly generated numbers

// into strings so that they can be displayed
// in the label controls.
[Link] = [Link]();
[Link] = [Link]();
 // 'sum' is the name of the NumericUpDown control.
// This step makes sure its value is zero before
// adding any values to it.
[Link] = 0;

// Fill in the subtraction problem.

minuend = [Link](1, 101);
subtrahend = [Link](1, minuend);
[Link] = [Link]();
[Link] = [Link]();
[Link] = 0;

// Fill in the multiplication problem.

multiplicand = [Link](2, 11);
multiplier = [Link](2, 11);
[Link] = [Link]();
[Link] = [Link]();
[Link] = 0;

// Fill in the division problem.

divisor = [Link](2, 11);
int temporaryQuotient = [Link](2, 11);
dividend = divisor * temporaryQuotient;
[Link] = [Link]();
[Link] = [Link]();
[Link] = 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();
[Link] = 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.

Executar o aplicativo
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 • 21/03/2023 • 9 minutos para o fim da leitura

Aplica-se a: Visual Studio Visual Studio para Mac Visual Studio Code

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 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#
 C#

public partial class Form1 : Form

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

// These integer variables store the numbers

// for the addition problem.
int addend1;
int addend2;

// These integer variables store the numbers

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

// These integer variables store the numbers

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

// These integer variables store the numbers

// for the division problem.
int dividend;
int divisor;

// This integer variable keeps track of the

// remaining time.
int timeLeft;

） 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.
 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#

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 == [Link])
&& (minuend - subtrahend == [Link])
&& (multiplicand * multiplier == [Link])
&& (dividend / divisor == [Link]))
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#

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.
[Link]();
[Link]("You got all the answers right!",
"Congratulations!");
[Link] = 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;
[Link] = timeLeft + " seconds";
}
else
{
// If the user ran out of time, stop the timer, show
// a MessageBox, and fill in the answers.
[Link]();
[Link] = "Time's up!";
[Link]("You didn't finish in time.", "Sorry!");
[Link] = addend1 + addend2;
[Link] = minuend - subtrahend;
[Link] = multiplicand * multiplier;
[Link] = dividend / divisor;
[Link] = 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#

C#

/// <summary>
/// Start the quiz by filling in all of the problem
/// values 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 = [Link](51);
addend2 = [Link](51);

// Convert the two randomly generated numbers

// into strings so that they can be displayed
// in the label controls.
[Link] = [Link]();
[Link] = [Link]();

// 'sum' is the name of the NumericUpDown control.

// This step makes sure its value is zero before
// adding any values to it.
[Link] = 0;

// Fill in the subtraction problem.

minuend = [Link](1, 101);
subtrahend = [Link](1, minuend);
[Link] = [Link]();
[Link] = [Link]();
[Link] = 0;

// Fill in the multiplication problem.

multiplicand = [Link](2, 11);
multiplier = [Link](2, 11);
[Link] = [Link]();
[Link] = [Link]();
[Link] = 0;

// Fill in the division problem.

divisor = [Link](2, 11);
int temporaryQuotient = [Link](2, 11);
dividend = divisor * temporaryQuotient;
[Link] = [Link]();
[Link] = [Link]();
[Link] = 0;
 // Start the timer.
timeLeft = 30;
[Link] = "30 seconds";
[Link]();
}

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.

Executar o aplicativo
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 • 21/03/2023 • 4 minutos para o fim da leitura

Aplica-se a: Visual Studio Visual Studio para Mac Visual Studio Code

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.

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#

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 = [Link]().Length;
[Link](0, lengthOfAnswer);
}
}

） 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.
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 [Link] . 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 subtração.

2. 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.

3. Repita as duas etapas anteriores para os controles NumericUpDown de

multiplicação e divisão.

Executar o aplicativo
 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#

[Link] = [Link];

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
programação e design no IDE do Visual Studio:

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 • 5 minutos para o fim da leitura

Aplica-se a: Visual Studio Visual Studio para Mac Visual Studio Code

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.

Neste primeiro tutorial, você aprenderá a:

＂ 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
Você precisa do Visual Studio para concluir este tutorial. Visite a página de downloads
do Visual Studio para obter uma versão gratuita.

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.

1. Abra o Visual Studio.

2. Na janela inicial, selecione Criar um novo projeto.

3. Na janela Criar um projeto, pesquise Windows Forms. Em seguida, selecione Área

de Trabalho na lista Todos os tipos de projeto.

4. Selecione o modelo Windows Forms App (.NET Framework) para C# ou Visual

Basic e, em seguida, selecione Avançar.

７ Observação
 Se você não encontrar o modelo do Aplicativo do Windows Forms (.NET
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
ferramentas e recursos.

Em seguida, no Instalador do Visual Studio, selecione Desenvolvimento da

área de trabalho do .NET.

Selecione o botão Modificar no Instalador do Visual Studio. Pode ser

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.

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.

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ê [Link] [Design] para C# ou [Link] [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 • 8 minutos para o fim da leitura

Aplica-se a: Visual Studio Visual Studio para Mac Visual Studio Code

Nesta série de quatro tutoriais, você cria um jogo da memória em que o jogador
encontra pares de ícones ocultos.

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.

Neste segundo tutorial, você aprenderá como:

＂ 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 [Link] se você estiver usando C# ou [Link] 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#

public partial class Form1 : Form

{
// 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

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.

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 [Link])
{
Label iconLabel = control as Label;
if (iconLabel != null)
{
int randomNumber = [Link]([Link]);
[Link] = icons[randomNumber];
// [Link] = [Link];
 [Link](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

[Link]
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#

[Link] = [Link];

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 [Link]

ou [Link] 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 ([Link] == [Link])
return;

[Link] = [Link];
}
}

７ 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 • 10/03/2023 • 9 minutos para o fim da leitura

Aplica-se a: Visual Studio Visual Studio para Mac Visual Studio Code

Nesta série de quatro tutoriais, você cria um jogo da memória em que o jogador
encontra pares de ícones ocultos.

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. Faça 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#
 public partial class Form1 : Form
{
// 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

Use o controle da linguagem de programação no canto superior direito desta

página para exibir o snippet de código do C# ou o do Visual Basic.

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.

1. 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() ( [Link] = [Link]; ) e a substitua pela

instrução if a seguir.

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 ([Link] == [Link])
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;
[Link] = [Link];

return;
}
}
}

1. 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 fica preto. 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 Jogo da Memória usa um controle Timer do aplicativo. 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#

/// <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>
/// <param name="e"></param>
private void timer1_Tick(object sender, EventArgs e)
{
// Stop the timer
[Link]();

// Hide both icons

[Link] = [Link];
[Link] = [Link];

// 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.

1. 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#

/// <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)
{
// 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 ([Link] == true)
return;

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 ([Link] == [Link])
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;
[Link] = [Link];
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;
[Link] = [Link];

// 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)
[Link]();
}
}

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.

1. 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 • 7 minutos para o fim da leitura

Aplica-se a: Visual Studio Visual Studio para Mac Visual Studio Code

Nesta série de quatro tutoriais, você cria um jogo da memória em que o jogador
encontra pares de ícones ocultos.

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#

// 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;
[Link] = [Link];

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

// black and reset firstClicked and secondClicked
// so the player can click another icon
if ([Link] == [Link])
{
firstClicked = null;
secondClicked = null;
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)
[Link]();
}
}

） 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.

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#

/// <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 [Link])
{
Label iconLabel = control as Label;

if (iconLabel != null)
{
if ([Link] == [Link])
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
[Link]("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#

// 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;
[Link] = [Link];

// 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 ([Link] == [Link])
{
firstClicked = null;
secondClicked = null;
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 [Link]. 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
programação e design no IDE do Visual Studio:

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 • 21/03/2023 • 6 minutos para o fim da leitura

Aplica-se a: Visual Studio Visual Studio para Mac Visual Studio Code

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 • 17/03/2023 • 8 minutos para o fim da leitura

Aplica-se a: Visual Studio Visual Studio para Mac Visual Studio Code

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.

Se você ainda não tiver instalado o Visual Studio, acesse a página Downloads do Visual
Studio para instalá-lo gratuitamente.

Abrir um projeto de um repositório GitHub

O Visual Studio facilita a abertura de um projeto de um repositório. Você pode fazer isso
quando iniciar o Visual Studio ou diretamente de dentro do Visual Studio IDE.

Veja aqui como fazer isso.

Usar a janela de início

1. Abra o Visual Studio.

2. Na janela inicial, selecione Clonar um repositório.

3. Insira ou digite a localização do repositório e, em seguida, selecione o botão
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 adicionar 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. 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. E se você receber uma notificação de
confiança e quiser saber mais sobre ela, consulte a página Definir
configurações de confiança para arquivos e pastas.

Mostrar arquivos no Gerenciador de Soluções

1. Em seguida, o Visual Studio carrega as soluções do repositório usando o Modo de
Exibição de Pasta no Gerenciador de Soluções.

Você pode exibir uma solução no Modo de Exibição de Solução clicando duas
vezes em seu arquivo .sln.

Ou, você pode selecionar o botão Alternar Modos de Exibição e, em seguida,

selecionar [Link] para exibir o código de uma solução.
  Dica

A exibição padrão é definida como Modo de Exibição de Pasta. Você pode alterá-lo
para o Modo de Exibição de Solução no menu Git. Selecione
Configurações>Controle do Código-Fonte>Configurações globais do
Git>Carregar a solução automaticamente ao abrir um repositório do Git para
fazer isso.

Abrir um projeto localmente de um repositório GitHub clonado

anteriormente
1. Abra o Visual Studio.

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.
  Dica

Se você abriu o projeto ou a solução recentemente, selecione-o na seção

Abrir recente para abri-lo rapidamente novamente.

Iniciar codificação!

Usar o IDE
Você também pode usar o menu Git ou o controle Selecionar Repositório no Visual
Studio IDE para interagir com pastas e arquivos de um repositório.

Veja aqui como fazer isso.

Para clonar um repositório e abrir um projeto

1. No Visual Studio IDE, selecione o menu Git e, em seguida, selecione Clonar
Repositório.
 2. Siga os prompts para se conectar ao repositório Git que inclui os arquivos que
você está procurando.

Para abrir pastas e arquivos locais

1. No Visual Studio IDE, selecione o menu Git, selecione Repositórios Locais e, em
seguida, selecione Abrir Repositório Local.

Como alternativa, você pode executar a mesma tarefa do Gerenciador de

Soluções. Para fazer isso, escolha o controle Selecionar Repositório, selecione o
ícone de reticências ao lado da caixa Filtrar repositórios e, em seguida, selecione
Abrir Repositório Local.
 2. Siga os prompts para se conectar ao repositório Git que possui os arquivos que
você está procurando.

Procurar um repositório do Azure DevOps

Veja como procurar e clonar um repositório do Azure DevOps usando o Visual Studio.

1. Abra o Visual Studio.

2. Na janela inicial, selecione Clonar um repositório.

 3. Na seção Navegar em um repositório, selecione Azure DevOps.

4. Siga os prompts para clonar um repositório do Azure DevOps que inclui os

arquivos que você está procurando e abra seu projeto.

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 [Link]

Confira também
Documentação de controle de versão do Visual Studio
Saiba como usar o editor de código com
C#
Artigo • 28/09/2022 • 11 minutos para o fim da leitura

Aplica-se a: Visual Studio Visual Studio para Mac Visual Studio Code

Nesta introdução de 10 minutos ao editor de código no Visual Studio, adicionaremos

código a um arquivo para examinar algumas das maneiras que o Visual Studio facilita a
gravação, a navegação e a compreensão do código C#.

Se você ainda não instalou o Visual Studio, acesse a página de 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
[Link] 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 escolha Continuar sem código na janela
inicial 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#. Você
não precisa criar um projeto completo do Visual Studio para obter alguns dos
 benefícios que o editor de código oferece– tudo o que você precisa é de 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 . svm static void Main significa — não se preocupe se você ainda
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á a assinatura do static void Main() método ser adicionada ao arquivo.
O método Main() é o ponto de entrada para aplicativos C#.

Os snippets de código disponíveis variam para diferentes linguagens de programação.

Você pode examinar os snippets de código disponíveis para seu idioma escolhendo
Editar>Snippet de Inserçãodo IntelliSense> ou pressionando Ctrl+K, Ctrl+X e
escolhendo a pasta para sua linguagem de programação. Para C#, a lista de snippets
tem esta aparência:

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 na barra de menus do Visual Studio,
ajuda a torná-lo mais produtivo conforme você codifica. Por exemplo, você pode
alternar o modo de conclusão do IntelliSense , aumentar ou diminuir um recuo de linha
ou comentar o código que não deseja compilar.

Vamos comentar algum código.

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

C#

// someWords is a string array.

string[] someWords = {
"the",
"quick",
"brown",
"fox",
"jumps"
};

string[] moreWords = {
"over",
"the",
"lazy",
"dog"
};

// Alphabetically sort the words.

IEnumerable<string> query = from word in someWords
orderby word
select word;

2. Não estamos usando a moreWords variável, mas podemos usá-la mais tarde para
que não queiramos excluí-la. Em vez disso, vamos comentar essas linhas. Selecione
toda a definição de moreWords até o ponto e vírgula de fechamento e escolha o
botão Comentar as linhas selecionadas na barra de ferramentas. Se preferir usar o
teclado, pressione Ctrl+E, Ctrl+C.
 Os caracteres de comentários // de C# são adicionados ao início de cada linha
selecionada para comentar o código.

Recolher blocos de código

Não queremos ver o construtor vazio para o qual foi gerado Class1 , portanto, para
desabar nossa visão do código, vamos recolhê-lo. Escolha a pequena caixa cinza com o
sinal de subtração dentro da margem da primeira linha do construtor. Ou, se preferir
usar o teclado, coloque o cursor em qualquer lugar no código do construtor e pressione
Ctrl+M, Ctrl+M.

O bloco de código é recolhido apenas na primeira linha, seguido por um sinal de

reticências ( ... ). Para expandir o bloco de código novamente, selecione a mesma caixa
cinza que agora tem um sinal de adição ou pressione Ctrl+M, Ctrl+M novamente. Esse
recurso é chamado Delineamento e é especialmente útil quando você está recolhindo
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 ou
variável. Uma maneira é ir para a definição, em qualquer arquivo que o tenha,
escolhendo Ir para Definição ou pressionando F12 em qualquer lugar em que um
símbolo for referenciado. Uma maneira ainda mais rápida que não afasta seu foco do
código em que você está trabalhando é usar a Definição de Espiada.

Vamos espiar a definição do tipo string .

1. Clique com o botão direito do mouse em qualquer ocorrência de string e escolha

Espiar Definição no menu de conteúdo. Ou pressione Alt+F12.

Uma janela pop-up será exibida com a definição da classe String . Você pode rolar
na janela pop-up ou até mesmo inspecionar a definição de outro tipo do código
 inspecionado.

2. Feche a janela de definição de espiada escolhendo a caixa pequena com um "x" no

canto superior direito da janela pop-up.

Usar o IntelliSense para completar palavras

O IntelliSense é um recurso inestimável quando você está codificando. Ele pode mostrar
informações sobre membros disponíveis de um tipo ou detalhes de parâmetros para
sobrecargas diferentes de um método. Você também pode usar o IntelliSense para
completar uma palavra depois que você digitar caracteres suficientes para desambiguá-
la.

Vamos adicionar uma linha de código para imprimir as cadeias de caracteres ordenadas
na janela de console, que é o local padrão para envio da saída do programa.

1. Abaixo da variável query , comece a digitar o código a seguir:

C#

foreach (string str in qu

Você verá um pop-up do IntelliSense aparecer com informações sobre o query

símbolo.
 2. Para inserir o restante da palavra query usando a conclusão da palavra IntelliSense,
pressione Tab.

3. Finalize o bloco de código para que ele se pareça com o seguinte código. Você
pode praticar mais com snippets de código inserindo e pressionando cw Tab duas
vezes para gerar a [Link] instrução.

C#

foreach (string str in query)

{
[Link](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 someWords como
unsortedWords .

1. Coloque o cursor sobre a definição da someWords variável e escolha Renomear no

menu de contexto ou clique com o botão direito do mouse ou no menu ou
pressione F2.

Uma caixa de diálogo Renomear aparece na parte superior direita do editor.

 2. Insira o nome desejado unsortedWords. Você verá que a referência na
unsortedWords query instrução de atribuição também é renomeada
automaticamente. Antes de pressionar Enter, marque a caixa de seleção Incluir
Comentários na caixa pop-up Renomear.

3. Pressione Enter ou escolha Aplicar na caixa de diálogo Renomear .

Ambas as ocorrências de someWords seu código foram renomeada, bem como o

texto someWords em seu comentário de código.

Próximas etapas
Saiba mais sobre projetos e soluções

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 • 17/03/2023 • 2 minutos para o fim da leitura

Aplica-se a: Visual Studio Visual Studio para Mac Visual Studio Code

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:

Método de Benefícios
build

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 – Criar projetos sem instalar o Visual Studio.

comando do – Executar builds em multiprocessador para todos os tipos de projeto.
MSBuild – Personalizar a maioria das áreas do sistema de build.

Azure – Automatizar o processo de build como parte de um pipeline de integração

Pipelines 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.

７ Observação

Este tópico aplica-se ao Visual Studio no Windows. Para o Visual Studio para Mac,
confira Compilar e criar no Visual Studio para Mac.

Visão geral da compilação no IDE

Quando você cria um projeto, o Visual Studio cria configurações de compilação padrão
para o projeto e para a solução que contém o projeto. Essas configurações definem a
maneira como as soluções e os projetos são criados e implantados. Configurações de
projeto, em particular, são exclusivas a uma plataforma de destino (por exemplo, o
Windows ou Linux) e tipo de build (por exemplo, depuração ou lançamento). Você pode
editar essas configurações como quiser e também pode criar suas próprias
configurações, conforme necessário.

Para 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

Noções básicas sobre plataformas de build
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.

Confira também
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 • 03/03/2023 • 22 minutos para o fim da leitura

Aplica-se a: Visual Studio Visual Studio para Mac Visual Studio Code

Este artigo apresenta os recursos do depurador do Visual Studio passo a passo. Caso
deseje obter uma exibição de nível superior das funcionalidades do depurador, confira
Introdução ao depurador. Quando você depura seu aplicativo, isso normalmente
significa executar o aplicativo com o depurador anexado. Quando você faz isso, o
depurador fornece várias maneiras de mostrar o que o código está fazendo enquanto é
executado. Você pode percorrer o código e examinar os valores armazenados em
variáveis, definir inspeções em variáveis para ver quando os valores mudam, examinar o
caminho de execução do código, ver se um branch de código está em execução e assim
por diante. Se esta for sua primeira tentativa de depurar um código, é interessante ler
Depuração para iniciantes antes continuar neste artigo.

Embora o aplicativo de demonstração esteja em C#, a maioria dos recursos são

aplicáveis a C++, Visual Basic, F#, Python, JavaScript e outras linguagens compatíveis
com o Visual Studio (o F# não é compatível com editar e continuar. O F# e o JavaScript
não são compatíveis com a 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ê precisa do Visual Studio 2022 instalado e a carga de trabalho Desenvolvimento de
área de trabalho do .NET.

Se você ainda não tiver instalado o Visual Studio, acesse a página Downloads do Visual
Studio para instalá-lo gratuitamente.

Se você já tem o Visual Studio, mas a carga de trabalho Desenvolvimento de área de

trabalho do .NET não estiver instalada, acesse Ferramentas>Obter Ferramentas e
Recursos..., que inicia o Instalador do Visual Studio. No Instalador do Visual Studio,
escolha a carga de trabalho Desenvolvimento de área de trabalho do .NET e selecione
Modificar.

Criar um projeto
Primeiro, você vai criar um projeto de aplicativo de console do .NET Core. O tipo de
projeto inclui todos os arquivos de modelo que você precisará, mesmo sem adicionar
nada!

1. Abra o Visual Studio. Se a janela inicial não estiver aberta, escolha Arquivo>Janela
Inicial.

2. Na tela Iniciar, selecione Criar um novo projeto.

3. Na janela Criar um novo projeto, insira ou digite console na caixa de pesquisa. Em

seguida, escolha C# na lista Linguagem de programação e, em seguida, escolha
Windows na lista Plataforma.

Depois de aplicar os filtros de linguagem e plataforma, escolha o modelo

Aplicativo de Console e, em seguida, escolha 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 Desenvolvimento de área de trabalho do
.NET.

4. Na janela Configurar seu novo projeto, digite ou insira GetStartedDebugging na

caixa Nome do projeto. Em seguida, escolha Avançar.

5. Na janela Informações adicionais, verifique se o .NET 6.0 (suporte a longo prazo)

está selecionado no menu suspenso Estrutura e escolha Criar.

O Visual Studio abre seu novo projeto.

Criar o aplicativo
No [Link], 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 < [Link]; i++)
{
name += letters[i];
a[i] = i + 1;
SendMessage(name, a[i]);
}
[Link]();
}

static void SendMessage(string name, int msg)

{
[Link]("Hello, " + name + "! Count to " + msg);
}
}

Inicie o depurador.
Na maioria das vezes, usamos atalhos de teclado aqui, porque é uma forma rápida de
executar comandos do depurador. Comandos equivalentes, como comandos da barra
de ferramentas ou do menu, também são indicados.

1. Para iniciar o depurador, selecione F5 ou escolha o botão Destino de Depuração

na barra de ferramentas Padrão ou escolha o botão Iniciar Depuração na barra de
ferramentas Depurar ou escolha Depurar>Iniciar Depuração na barra de menus.

A tecla F5 inicia o aplicativo com o depurador anexado ao processo do aplicativo.

Como não fizemos nada especial para examinar o código, o aplicativo é executado
até a conclusão e você vê a saída no 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

2. Para interromper o depurador, selecione Shift+F5 ou escolha o botão Parar

Depuração na barra de ferramentas Depurar ou escolha Depurar>Parar
Depuração na barra de menus.

3. Na janela do console, selecione qualquer 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 da 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 recurso essencial de uma depuração confiável. Você

pode definir pontos de interrupção nos locais em que deseja que o Visual Studio
pause o código em execução para que você possa examinar os valores das
variáveis ou o comportamento da memória ou para saber se uma ramificação de
código está sendo executada ou não.

2. Para iniciar a depuração, selecione F5 ou escolha o botão Destino de Depuração

na barra de ferramentas Padrão ou escolha o botão Iniciar Depuração na barra de
ferramentas Depurar ou escolha Depurar>Iniciar Depuração na barra de menus. O
aplicativo é iniciado e o depurador executa até a linha de código em que você
definiu o ponto de interrupção.

A seta amarela aponta para a instrução na qual o depurador fez uma pausa. A
execução do aplicativo está pausada no mesmo ponto, com a instrução ainda não
executada.

Quando o aplicativo não estiver em execução, o F5 iniciará o depurador, que

executará o aplicativo até atingir o primeiro ponto de interrupção. Se o aplicativo
estiver em pausa em um ponto de interrupção, o F5 continuará executando o
aplicativo até chegar ao próximo ponto de interrupção.
 Os pontos de interrupção são recursos úteis quando você sabe a linha ou a seção
de código que deseja examinar em detalhes. Para saber mais 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
1. Enquanto pausado na instrução name += letters[i] , passe o mouse sobre a
letters variável para ver uma dica de dados mostrando o tamanho da matriz e o

tipo de elemento: char[10] .

７ Observação

Um dos recursos mais úteis do depurador é sua capacidade de inspecionar

uma variável. Muitas vezes, ao tentar depurar um problema, você está
tentando descobrir se as variáveis têm valores que você espera em um
determinado momento. Ver dicas de dados é uma boa maneira de verificar
isso.

2. Expanda a variável letters para exibir todos os elementos da matriz e seus

valores.

3. Passe o mouse sobre a variável name para ver seu valor atual, que é uma cadeia de
caracteres vazia.

4. Para avançar o depurador até a próxima instrução, selecione F10 ou escolha o

botão Contornar na barra de ferramentas Depurar ou escolha Depurar>Contornar
na barra de menus. Selecione F10 mais duas vezes para passar da chamada de
método SendMessage .
 O F10 avança o depurador sem intervir na função ou nos métodos, embora os
respectivos códigos ainda sejam executados. Dessa forma, pulamos a depuração
do código no método SendMessage , no qual não temos interesse no momento.

5. Para iterar no loop for algumas vezes, selecione F10 repetidamente. Durante cada
iteração de loop, pause no ponto de interrupção e passe o mouse sobre a variável
name para verificar o valor dela na dica de dados.

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, selecione F5, que avança até o ponto de interrupção em vez da

próxima instrução.

6. Enquanto estiver pausado no loop for do método Main , selecione F11 ou escolha
o botão Intervir na barra de ferramentas Depurar ou escolha Depurar>Intervir na
barra de menus até chegar à chamada de método SendMessage .

O depurador deve estar pausado nesta linha de código:

SendMessage(name, a[i]);

7. Para intervir no método SendMessage , selecione F11 novamente.

O ponteiro amarelo avança para o método SendMessage .

O F11 ajuda você a examinar mais detalhadamente o fluxo de execução do código.

Para intervir em um método de uma chamada de método, selecione F11. Por
padrão, o depurador ignora a intervenção em métodos que não são de usuário.
Para saber mais sobre a depuração de código que não é de usuário, confira
Apenas Meu Código.

Depois de terminar de depurar o método SendMessage , você estará pronto para

retornar ao loop for do método main .
 8. Para sair do método SendMessage , selecione Shift+F11 ou escolha o botão Sair na
barra de ferramentas Depurar ou escolha Depurar>Sair na barra de menus.

A opção Sair retoma a execução do aplicativo e avança o depurador até que o

método ou a função atual retorne.

Você verá o ponteiro amarelo 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, passe o mouse sobre a chamada de método

[Link] no método SendMessage até que o botão Executar até o Clique
apareça à esquerda. A dica de ferramenta para o botão mostra "Realizar a
execução até aqui".

3. Escolha o botão Executar até o Clique. Como alternativa, com o cursor na

instrução [Link] , selecione Ctrl+F10. Ou clique com o botão direito do
mouse na chamada de método [Link] e escolha Executar até o Cursor
no menu de contexto.

O depurador avança até a chamada de método [Link] .

O uso do botão Executar até o Clique é semelhante à configuração de um ponto

de interrupção temporário e é útil para se locomover rapidamente em uma região
visível do código do aplicativo em um arquivo aberto.

Reinicie o aplicativo rapidamente

Para executar novamente o aplicativo desde o início no depurador, selecione
Ctrl+Shift+F5 ou escolha o botão Reiniciar na barra de ferramentas Depurar ou escolha
Depurar>Reiniciar na barra de menus.

O comando Reiniciar interrompe o depurador e, em seguida, reinicia-o em apenas uma

etapa. Quando o depurador for reiniciado, ele vai executar até o primeiro ponto de
interrupção, que aquele que você definiu anteriormente dentro do loop for e, em
seguida, pausará.

Inspecionar variáveis com as janelas Autos e

Locais
As janelas Autos e Locais mostram valores de variáveis durante a depuração. As janelas
só ficam disponíveis durante uma sessão de depuração. A janela Autos mostra variáveis
usadas na linha atual em que o depurador está e na linha anterior. A janela Locals
mostra as variáveis definidas no escopo local, que geralmente é o método ou a função
atual.

1. Enquanto o depurador estiver em pausa, veja a janela Autos na parte inferior do

editor de código.

Se a janela Autos estiver fechada, selecione Ctrl+D, A ou escolha

Depurar>Janelas>Autos na barra de menus.

2. Com o depurador ainda em pausa, veja a janela Locais em uma guia ao lado da
janela Autos.

Se a janela Locais estiver fechada, selecione Ctrl+D, L ou escolha

Depurar>Janelas>Locais.

3. Na janela Locais, expanda a variável letters para ver seus elementos de matriz e
os respectivos valores.
Para obter mais informações sobre como usar as janelas Autos e Locais, confira
Inspecionar variáveis nas janelas Autos e Locais.

Definir uma inspeção

Você pode especificar uma variável ou uma expressão na qual deseja ficar de olho ao
percorrer o código, adicionando-a à janela Inspeção.

1. Enquanto o depurador está em pausa, clique com o botão direito do mouse na

variável name e escolha Adicionar Inspeção.

A janela Inspeção abre-se por padrão na parte inferior do editor de código.

2. Agora que você definiu uma inspeção na variável name , percorra o código para ver
o valor da variável name mudar com cada iteração do loop for .

Ao contrário das outras janelas de variáveis, a janela Inspeção sempre mostra as

variáveis que você está inspecionando, embora elas fiquem esmaecidas quando
estão fora do escopo.

Para obter mais informações sobre a janela Inspeção, confira Inspecionar variáveis com
Janelas de inspeção.

Examinar a pilha de chamadas

A Pilha de Chamadas pode ajudar você a entender o fluxo de execução do aplicativo,
mostrando a ordem em que métodos e funções estão sendo chamados.

1. Enquanto o depurador estiver pausado no loop for , veja a janela Pilha de

Chamadas que é aberta por padrão no painel inferior direito do editor de código.
 Se a janela Pilha de Chamadas estiver fechada, selecione Ctrl+D, C ou escolha
Depurar>Janelas>Pilha de Chamadas na barra de menus.

Na janela Pilha de Chamadas, você verá o ponteiro amarelo no método atual

Main .

2. Selecione F11 algumas vezes até que o depurador seja pausado no método
SendMessage .

A linha superior da janela Pilha de Chamadas mostra a função atual, que é o

método SendMessage . A segunda linha mostra que o método SendMessage foi
chamado pelo método Main .

７ Observação

A janela Pilha de Chamadas é semelhante à perspectiva de Depuração em

alguns IDEs, como o Eclipse.

Na janela Pilha de Chamadas, você pode clicar duas vezes em uma linha de
código para acessar esse código-fonte, o que vai alterar o escopo atual que está
sendo inspecionado pelo depurador. Essa ação não avança o depurador.

Você também pode usar os menus acessados ao clicar com o botão direito do
mouse na janela Pilha de Chamadas para fazer outras coisas. Por exemplo, você
pode inserir pontos de interrupção em funções específicas, avançar o depurador
usando Executar até o Cursor ou acessar o código-fonte.

Para obter mais informações sobre a Pilha de Chamadas, confira Como examinar a pilha
de chamadas.

Alterar o fluxo de execução

Você pode mover o ponteiro de execução para alterar o fluxo do aplicativo durante a
depuração.

1. Com o depurador pausado na chamada de método SendMessage no loop for ,

selecione F11 três vezes para intervir no método SendMessage e passar pelo método
 [Link] depois de executá-lo.

Agora o depurador está em pausa na chave de fechamento final do método

SendMessage .

2. Use o mouse para pegar a seta amarela ou o ponteiro de execução (na margem
esquerda) e arraste o ponteiro uma linha para cima.

Agora o depurador está de volta à instrução [Link] .

3. Selecione F11.

O depurador executa novamente o método [Link] e você verá uma

linha duplicada na saída da janela do console.

4. Selecione F5 para continuar a execução do aplicativo.

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

Use esse recurso com cuidado. Você verá um aviso na dica de ferramenta do
ponteiro de execução sobre a possibilidade de consequências indesejadas. Você
também pode ver outros avisos. A movimentação do ponteiro de execução não
pode reverter seu aplicativo para um estado anterior.

Para obter mais informações sobre como alterar o fluxo de execução, confira Mover o
ponteiro para alterar o fluxo de execução.

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 • 27/09/2022 • 6 minutos para o fim da leitura

Aplica-se a: Visual Studio Visual Studio para Mac Visual Studio Code

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++, ilustrações estão em C#, mas os conceitos e
recursos se aplicam a 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 exemplo de teste de unidade, este artigo testa um projeto

simples do Console C# ou C++ "Olá, Mundo" 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()
{
[Link]("Hello World!");
}
}
}

2. No Gerenciador de Soluções, selecione o nó da solução. Em seguida, na barra de

menus superior, selecioneAdicionar>Arquivo>Novo Projeto.

3. Na caixa de diálogo novo projeto, localize o projeto de teste de unidade a ser

usado.
Digite o 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 de Teste de Unidade Nativa (C++) e selecione-o.

A partir do Visual Studio 2017 versão 14.8, os idiomas do .NET incluem modelos
internos para NUnit e xUnit. Para C++, neste exemplo, selecione o projeto De
Teste de Unidade Nativa , que usa o Microsoft Native Unit Test Framework. (Para
usar uma estrutura de teste do C++ diferente, consulte Escrevendo testes de
unidade para C/C++). Para Python, consulte Configurar testes de unidade no
código Python para configurar seu projeto de teste.

 Dica

Somente para C#, você pode criar projetos de teste de unidade 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 mostra um teste de unidade MSTest, com 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 corresponde à sua estrutura de teste: MSTest, NUnit ou
 xUnit (com suporte somente no .NET) ou C++ Microsoft Native Unit Test
Framework.

MSTest

C#

using [Link];
using [Link];
using System;

namespace HelloWorldTests
{
[TestClass]
public class UnitTest1
{
private const string Expected = "Hello World!";
[TestMethod]
public void TestMethod1()
{
using (var sw = new StringWriter())
{
[Link](sw);
[Link]();

var result = [Link]().Trim();

[Link](Expected, result);
}
}
}
}

Executar testes de unidade

1. Abra o Gerenciador de Testes.

Para abrir o Gerenciador de Testes, escolha oGerenciador de Testes> na barra de

menus superior (ou pressione Ctrl + E, T).

2. Execute os 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 de teste de unidade dinâmica

(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 essas etapas, 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 o

Google C++ Testing Framework já estão incluídas. 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.

Neste exemplo, selecione NUnit

 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 no Gerenciador de Testes ou clicando com o botão direito do

mouse no código de teste e escolhendo Executar Testes (ouCtrl + 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

Implantação de aplicativo Web do [Link]

ｇ TUTORIAL

Ferramenta de publicação

Azure

Obter configurações de publicação do IIS

Publicar com Git

Implantação do aplicativo C++

ｃ GUIA DE INSTRUÇÕES

Pacote do instalador

Configurar projeto

Implantação de aplicativo .NET./.NET Core

ｇ TUTORIAL

Ferramenta de publicação

ClickOnce
ClickOnce

Pacote do instalador

ｃ GUIA DE INSTRUÇÕES

Empacotar um aplicativo da área de trabalho para a Windows Store

Implantação de aplicativo da área de trabalho do .NET Framework

ｇ TUTORIAL

ClickOnce

Pacote do instalador

Tipos de implantação adicionais

ｃ GUIA DE INSTRUÇÕES

Aplicativos [Link] no Serviço de Aplicativo do Linux

Aplicativos conteinerizados

Publicar pacotes do NuGet

Criar um banco de dados e adicionar
tabelas no Visual Studio
Artigo • 10/04/2023

Aplica-se a: Visual Studio Visual Studio para Mac Visual Studio Code

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.

７ 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 [Link] 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

[Link] 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 a cadeia de conexão do arquivo [Link] abrindo a janela
Propriedades da conexão de dados:

Selecione Exibir>Pesquisador de Objetos do SQL Server para abrir a janela

Pesquisador de Objetos do SQL Server. Expanda
(localdb)\MSSQLLocalDB>Bancos de Dados e clique com o botão direito em
[Link] (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 [Link] e
selecionando Propriedades.

 Dica

Se você não puder expandir o nó Conexões de Dados ou a conexão

[Link] 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 [Link]. Conclua a
adição da conexão selecionando OK.

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ó [Link].

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.

6. Na caixa de diálogo Visualizar Atualizações de Banco de Dados, selecione

Atualizar Banco de Dados.

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).

5. Na caixa de diálogo Visualizar Atualizações de Banco de Dados, selecione

Atualizar Banco de Dados.

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.

Confira também
Acessando dados no Visual Studio