Exercício – Criar lógica de decisão com instruções if

19 minutos

A maioria dos aplicativos inclui um grande número de caminhos de execução. Por exemplo, um aplicativo pode implementar caminhos de execução diferentes com base na opção de menu que um usuário seleciona. Os desenvolvedores se referem ao código que implementa caminhos de execução diferentes como branches de código.

A instrução de branching de código usada mais amplamente é a instrução if. A instrução if usa uma expressão booliana colocada entre parênteses. Se a expressão for verdadeira, o código após a instrução if será executado. Caso contrário, o runtime do .NET ignora o código e não o executa.

Neste exercício, você praticará a escrita de instruções if criando um jogo. Primeiro, você definirá as regras do jogo e as implementará no código.

Você usará o método Random.Next() para simular a rolagem de três dados de seis lados cada. Você avaliará os valores para calcular a pontuação. Se a pontuação for superior a um total arbitrário, você exibirá uma mensagem de vitória para o usuário. Se a pontuação estiver abaixo do corte, você exibirá uma mensagem de derrota para o usuário.

Se quaisquer dois dados rolados resultarem no mesmo valor, você receberá dois pontos de bônus pelo resultado duplicado.
Se os três dados rolados resultarem no mesmo valor, você receberá seis pontos de bônus pelo resultado triplicado.
Se a soma dos três dados rolados, mais quaisquer pontos de bônus, for igual ou maior que 15, você vencerá o jogo. Caso contrário, você perderá.

Você refinará as regras conforme for aprendendo mais sobre a instrução if.

Importante

Este exercício faz uso extensivo da classe System.Random. Confira o módulo "Chamar métodos da biblioteca de classes .NET usando C#" do Microsoft Learn para lembrar-se de como Random.Next() funciona.

Preparar o ambiente de codificação

Este módulo inclui atividades que guiarão você através do processo de criação e execução de um código de exemplo. Incentivamos você a concluir essas atividades usando o Visual Studio Code como ambiente de desenvolvimento. Usar o Visual Studio Code nessas atividades ajudará você a se sentir mais confortável escrevendo e executando o código em um ambiente de desenvolvedor usado por profissionais em todo o mundo.

Abra o Visual Studio Code.

Você pode usar o menu Iniciar do Windows (ou recurso equivalente em outro sistema operacional) para abrir o Visual Studio Code.
No Visual Studio Code, no menu Arquivo, selecione Abrir Pasta.
Na caixa de diálogo Abrir Pasta, navegue até a pasta Área de Trabalho do Windows.

Se você mantém os projetos de código em um local de pasta diferente, use esse local. Neste treinamento, o importante é ter um local fácil de localizar e lembrar.
Na caixa de diálogo Abrir Pasta, selecione Selecionar Pasta.

Se aparecer uma caixa de diálogo de segurança perguntando se confia nos autores, selecione Sim.
No Visual Studio Code, no menu Terminal, selecione Novo Terminal.

Observe que o prompt de comando no painel Terminal exibe o caminho da pasta atual. Por exemplo:
```
C:\Users\someuser\Desktop>
```
Observação

Se você estiver trabalhando no próprio computador em vez de em uma área restrita ou em um ambiente hospedado e tiver concluído outros módulos do Microsoft Learn desta série C#, talvez já tenha criado uma pasta de projeto para exemplos de código. Se esse for o caso, você poderá ignorar a próxima etapa, que será usada para criar o aplicativo de console na pasta TestProject.
No prompt de comando terminal, para criar um novo aplicativo de console em uma pasta especificada, insira o seguinte prompt:
```
dotnet new console -o ./CsharpProjects/TestProject
```
Este comando da CLI do .NET usa um modelo de programa .NET para criar o novo projeto de aplicativo de console C# no local da pasta especificada. O comando cria as pastas CsharpProjects e TestProject para você e usa TestProject como o nome do arquivo .csproj.

Se uma mensagem for exibida informando que os arquivos já existem, continue com as próximas etapas. Você reutilizará os arquivos de projeto existentes.
No modo de exibição EXPLORER, expanda a pasta CsharpProjects .

Você deverá ver a pasta TestProject e dois arquivos, um arquivo de programa C# chamado Program.cs e um arquivo de projeto em C# chamado TestProject.csproj.
No Visual Studio Code, no menu Arquivo, selecione Abrir Pasta.
Na caixa de diálogo Abrir Pasta , selecione a pasta CsharpProjects e selecione Selecionar Pasta.
No modo de exibição EXPLORER, expanda a pasta TestProject e selecione Program.cs.
Exclua as linhas de código existentes.

Você usará esse projeto de console C# para criar, compilar e executar exemplos de código durante este módulo.
Feche o painel do terminal.

Escrever código que gera três números aleatórios e os exibe na saída

Verifique se você tem o arquivo Program.cs vazio aberto no Visual Studio Code.

Para criar o código inicial deste exercício, insira o seguinte:

Random dice = new Random();

int roll1 = dice.Next(1, 7);
int roll2 = dice.Next(1, 7);
int roll3 = dice.Next(1, 7);

int total = roll1 + roll2 + roll3;

Console.WriteLine($"Dice roll: {roll1} + {roll2} + {roll3} = {total}");

Reserve um minuto para analisar o código que você inseriu.

Para começar, crie uma instância da classe System.Random e armazene uma referência ao objeto em uma variável chamada dice. Em seguida, chamamos o método Random.Next() no objeto dice três vezes, fornecendo os limites inferior e superior para restringir os valores possíveis entre 1 e 6 (não inclui o limite superior). Salve os três números aleatórios nas variáveis roll1, roll2 e roll3, respectivamente.

Em seguida, some as três jogadas de dados e salve o valor em uma variável inteira chamada total.

Por fim, use o método WriteLine() para exibir os três valores usando a interpolação de cadeia de caracteres.

Quando executar o código, você verá a seguinte mensagem (os números serão diferentes).
```
Dice roll: 4 + 5 + 2 = 11
```
Essa primeira tarefa foi de preparação. Agora, você pode adicionar a lógica de decisão ao seu código para tornar o jogo mais interessante.

Adicionar uma instrução if para exibir mensagens diferentes com base no valor da variável total

No Editor do Visual Studio Code, localize o cursor na parte inferior do arquivo de código e crie uma linha de código em branco.
Para criar seu primeiro recurso de jogo, insira as instruções if a seguir.
```
if (total > 14)
{
    Console.WriteLine("You win!");
}

if (total < 15)
{
    Console.WriteLine("Sorry, you lose.");
}
```
Essas duas instruções if são usadas para lidar com os cenários de vitória e derrota. Reserve um minuto para analisar a primeira instrução if.

A instrução if é composta por três partes:
- A palavra-chave if
- Uma expressão booliana entre parênteses ()
- Um bloco de código definido por chaves { }
Em tempo de execução, a expressão booliana total > 14 é avaliada. Se a instrução for verdadeira (se o valor de total for maior que 14), o fluxo da execução continuará para o código definido no bloco de código. Em outras palavras, ele executará o código entre as chaves.

No entanto, se a expressão booliana for falsa (se o valor de total não for maior que 14), o fluxo de execução ignorará o bloco de código. Em outras palavras, ele não executará o código entre chaves.

Por fim, a segunda instrução if controla a mensagem caso o usuário perca. Na próxima unidade, você usará uma variação na instrução if para encurtar essas duas instruções em uma única instrução e expressar a intenção mais claramente.

O que é uma expressão booliana?

Uma expressão booliana é qualquer código que retorna um valor booliano, true ou false. As expressões boolianas mais simples são simplesmente os valores true e false. Como alternativa, uma expressão booliana pode ser o resultado de um método que retorna o valor true ou false. Por exemplo, este é um exemplo de código simples que usa o método string.Contains() para avaliar se uma cadeia de caracteres contém outra.

string message = "The quick brown fox jumps over the lazy dog.";
bool result = message.Contains("dog");
Console.WriteLine(result);

if (message.Contains("fox"))
{
    Console.WriteLine("What does the fox say?");
}

Como retorna um valor de message.Contains("fox") ou true, false se qualifica como uma expressão booliana e pode ser usado em uma instrução if.

Outras expressões boolianas simples podem ser criadas usando operadores para comparar dois valores. Os operadores incluem:

==, o operador "igual" para testar a igualdade
>, o operador "maior que", para testar se o valor à esquerda é maior que o valor à direita
<, o operador "menor que", para testar se o valor à esquerda é menor que o valor à direita
>=, o operador "maior ou igual a"
<=, o operador "menor ou igual a"
e assim por diante

Observação

A série de treinamento em C# no Microsoft Learn dedica um módulo inteiro a expressões boolianas. Há muitos operadores que podemos usar para construir uma expressão booliana, e abordaremos apenas algumas das noções básicas aqui. Para saber mais sobre as expressões boolianas, confira o módulo "Avaliar expressões boolianas para tomar decisões em C#" do Microsoft Learn.

Nesse exemplo, você avaliou a expressão booliana total > 14. No entanto, você poderia ter escolhido a expressão booliana total >= 15, uma vez que, neste caso, elas são a mesma coisa. Considerando que as regras do jogo especificam que "se a soma dos três dados, mais os bônus, é maior ou igual a 15, você ganha o jogo", você deve provavelmente implementar a expressão >= 15. Você fará essa alteração na próxima etapa do exercício.

O que é um bloco de código?

Um bloco de código é uma coleção de uma ou mais linhas de código definidas por um símbolo de chave de abertura e fechamento { }. Ele representa uma unidade de código completa com uma única finalidade em seu sistema de software. Nesse caso, no runtime, todas as linhas de código no bloco de código serão executadas se a expressão booliana for verdadeira. Por outro lado, se a expressão booliana for falsa, todas as linhas de código no bloco de código serão ignoradas.

Você também deve saber que os blocos de código podem conter outros blocos de código. Na verdade, é comum que um bloco de código esteja "aninhado" dentro de outro bloco de código em seus aplicativos. Você começará aninhando os próprios blocos de código mais adiante neste módulo, quando criar uma instrução if dentro do bloco de código de outra.

Observação

A série de treinamento em C# no Microsoft Learn dedica um módulo inteiro a noções básicas de blocos de código. Os blocos de código são fundamentais para compreender a organização e a estrutura do código. Além disso, eles definem os limites do escopo da variável. Para obter mais informações sobre blocos de código, confira o módulo intitulado "Escopo e lógica do controle de variáveis usando blocos de código em C#".

Adicionar outra instrução if para implementar o bônus por resultado duplicado

Em seguida, você pode implementar a regra: "Se dois dados rolados resultarem no mesmo valor, você receberá dois pontos bônus pelo resultado duplicado." Modifique o código da etapa anterior de forma a corresponder à seguinte listagem de código:

No Editor do Visual Studio Code, localize o cursor na linha de código em branco acima da primeira instrução if.
Para criar seu recurso de jogo "com resultado duplicado", insira a instrução if a seguir.
```
if ((roll1 == roll2) || (roll2 == roll3) || (roll1 == roll3))
{
    Console.WriteLine("You rolled doubles! +2 bonus to total!");
    total += 2;
}
```
Aqui, você combina três expressões boolianas para criar uma expressão booliana composta em uma única linha de código. Às vezes, isso é chamado de condição composta. Você tem um conjunto de parênteses externo que combina três conjuntos de parênteses internos separados por dois caracteres de pipe.

Os caracteres de pipe duplo || são o operador lógico OR, que basicamente afirma que "a expressão à minha esquerda OU a expressão à minha direita precisa ser verdadeira para que toda a expressão booliana seja verdadeira". Se as duas expressões boolianas forem falsas, a expressão booliana inteira será falsa. Use dois operadores lógicos OR para poder estender a avaliação para uma terceira expressão booliana.

Primeiro, você avalia (roll1 == roll2). Se for verdadeiro, a expressão inteira será verdadeira. Se for falso, você avaliará (roll2 == roll3). Se for verdadeiro, a expressão inteira será verdadeira. Se for falso, você avaliará (roll1 == roll3). Se for verdadeiro, a expressão inteira será verdadeira. Se for falso, a expressão inteira será falsa.

Se a expressão booliana composta for verdadeira, você executará o bloco de código a seguir. Desta vez, há duas linhas de código. A primeira linha de código imprime uma mensagem para o usuário. A segunda linha de código incrementa o valor de total em 2.
Para aprimorar a legibilidade do código, atualize a segunda instrução if da seguinte maneira:
```
if (total >= 15)
```
Agora você está usando o operador >= na expressão usada para avaliar uma jogada vencedora. O operador >= significa "maior ou igual a". Como resultado, você pode comparar total com um valor de 15, em vez de 14 . Com essas alterações, a expressão que você usa para avaliar uma jogada vencedora agora se assemelha à expressão que você avalia para uma jogada derrotada. Isso deve ajudar a tornar seu código mais fácil de entender (mais legível). Como você está lidando com valores inteiros, sua nova expressão (total >= 15) funcionará de maneira idêntica à que você escreveu anteriormente (total > 14).

Reserve um minuto para revisar seu código.

O código deverá corresponder ao seguinte:

Random dice = new Random();

int roll1 = dice.Next(1, 7);
int roll2 = dice.Next(1, 7);
int roll3 = dice.Next(1, 7);

int total = roll1 + roll2 + roll3;

Console.WriteLine($"Dice roll: {roll1} + {roll2} + {roll3} = {total}");

if ((roll1 == roll2) || (roll2 == roll3) || (roll1 == roll3))
{
    Console.WriteLine("You rolled doubles! +2 bonus to total!");
    total += 2;
}

if (total >= 15)
{
    Console.WriteLine("You win!");
}

if (total < 15)
{
    Console.WriteLine("Sorry, you lose.");
}

Observe o alinhamento aprimorado entre as expressões usadas para avaliar as jogadas vencedora e derrotada.

Adicionar outra instrução if para implementar o bônus por resultado triplicado

Em seguida, você pode implementar a regra: "se todos os três dados que você jogar resultarem no mesmo valor, você obterá seis pontos de bônus". Modifique o código das etapas anteriores para corresponder à seguinte listagem de código:

No Editor do Visual Studio Code, crie uma linha de código em branco embaixo do bloco de código da instrução if de "resultados duplicados".
Para criar seu recurso de jogo "com resultado triplicado", insira a instrução if a seguir.
```
if ((roll1 == roll2) && (roll2 == roll3)) 
{
    Console.WriteLine("You rolled triples! +6 bonus to total!");
    total += 6;
}
```
Aqui, você combina duas expressões boolianas para criar uma expressão booliana composta em uma única linha de código. Você tem um conjunto de parênteses externo que combina dois conjuntos de parênteses internos separados por dois caracteres de E comercial.

Os caracteres de E comercial duplos && são o operador lógico AND, que basicamente afirma que "somente se duas as expressões forem verdadeira, a expressão inteira será verdadeira". Nesse caso, se roll1 for igual a roll2, e roll2 for igual a roll3, por dedução, roll1 deverá ser igual a roll3 e o usuário teve um resultado triplicado.
No menu Arquivo do Visual Studio Code, clique em Salvar.

Reserve um minuto para revisar seu código.

Verifique se o código corresponde ao seguinte:

Random dice = new Random();

int roll1 = dice.Next(1, 7);
int roll2 = dice.Next(1, 7);
int roll3 = dice.Next(1, 7);

int total = roll1 + roll2 + roll3;

Console.WriteLine($"Dice roll: {roll1} + {roll2} + {roll3} = {total}");

if ((roll1 == roll2) || (roll2 == roll3) || (roll1 == roll3))
{
    Console.WriteLine("You rolled doubles! +2 bonus to total!");
    total += 2;
}

if ((roll1 == roll2) && (roll2 == roll3)) 
{
    Console.WriteLine("You rolled triples! +6 bonus to total!");
    total += 6;
}

if (total >= 15)
{
    Console.WriteLine("You win!");
}

if (total < 15)
{
    Console.WriteLine("Sorry, you lose.");
}

No modo de exibição EXPLORER, para abrir um Terminal no local da pasta TestProject, clique com o botão direito do mouse em TestProject e selecione Abrir no Terminal Integrado.

Um painel Terminal deve ser aberto e incluir um prompt de comando mostrando que o Terminal está aberto no local da pasta TestProject.
No prompt de comando do Terminal, para executar o código, digite dotnet run e pressione Enter.

Observação

Se você vir uma mensagem com a mensagem "Não foi possível encontrar um projeto a ser executado", verifique se o prompt de comando Terminal exibe o local esperado da pasta TestProject. Por exemplo: C:\Users\someuser\Desktop\csharpprojects\TestProject>

Você deverá ver uma saída semelhante a um dos seguintes resultados:
```
Dice roll: 3 + 6 + 1 = 10
Sorry, you lose.
```
Ou assim:
```
Dice roll: 1 + 4 + 4 = 9
You rolled doubles! +2 bonus to total!
Sorry, you lose.
```
Ou assim:
```
Dice roll: 5 + 6 + 4 = 15
You win!
```
Ou, se você tiver sorte, verá isto:
```
Dice roll: 6 + 6 + 6 = 18
You rolled doubles! +2 bonus to total!
You rolled triples! +6 bonus to total!
You win!
```
Mas, espere, você deve realmente recompensar o jogador com o bônus triplicado e duplicado? Afinal, uma jogada com resultado triplicado implica uma jogada com resultado duplicado. O ideal é que os bônus não sejam acumulados. Deve haver duas condições de bônus separadas. Esse é um bug na lógica que precisará ser corrigido.

Problemas na lógica e oportunidades para aprimorar o código

Embora seja um bom começo e você tenha aprendido muito sobre a instrução if, expressões boolianas, blocos de código, operadores lógicos OR e AND e assim por diante, há muito que pode ser aprimorado. Você vai fazer isso na próxima unidade.

Recapitulação

Use uma instrução if para ramificar sua lógica de código. A instrução de decisão if executará o código em seu bloco de código se sua expressão booliana for verdadeira. Caso contrário, o runtime ignorará o bloco de código e continuará para a próxima linha de código após o bloco de código.
Uma expressão booliana é qualquer expressão que retorna um valor booliano.
Os operadores boolianos comparam os dois valores, à esquerda e à direita, em termos de igualdade, comparação e muito mais.
Um bloco de código é definido por chaves { }. Ele coleta linhas de código que devem ser tratadas como uma única unidade.
O operador lógico AND && agrega duas expressões de forma que as duas subexpressões devam ser verdadeiras para que toda a expressão seja verdadeira.
O operador lógico OR || agrega duas expressões de forma que, se alguma das subexpressões for verdadeira, toda a expressão será verdadeira.

Comentários

Esta página foi útil?

Exercício – Criar lógica de decisão com instruções if

Verificar seu conhecimento

Comentários