Exercício – Criar matrizes e loops foreach

25 minutos

Neste exercício, você revisa o código do projeto Starter e, em seguida, começa a atualizar o aplicativo. Sua primeira tarefa de codificação é criar as matrizes que contêm as pontuações do exame estudantil. Depois que os dados do aplicativo estiverem disponíveis em matrizes, você começará a trabalhar em um foreach loop que pode ser usado para somar notas de alunos. As tarefas detalhadas que você concluir durante este exercício são:

Revisão de código: examine o conteúdo do arquivo Program.cs.
Matrizes: crie as matrizes que armazenam as notas de tarefa de cada aluno.
Iteração: crie um loop foreach que possa ser usado para somar as notas de tarefa de Sophia.
Calcule e exiba a nota média de tarefa de Sophia.
Teste de verificação: execute um teste de verificação para o código que você desenvolveu neste exercício.

Importante

Você precisa ter concluído as instruções de Instalação na unidade anterior. Prepare-se antes de começar este Exercício.

Examinar o conteúdo do arquivo Program.cs

Nesta tarefa, você examinará o código fornecido como um projeto inicial para este módulo. O arquivo Program.cs contém a versão inicial do aplicativo de classificação de aluno que você está atualizando.

Verifique se você tem a pasta GuidedProject aberta no Visual Studio Code.

A unidade Prepare-se (a unidade anterior neste módulo) inclui uma seção de preparação para este módulo de projeto guiado. A seção de preparação descreve o processo para baixar o código inicial e abrir a pasta do projeto Visual Studio Code. Se necessário, volte e siga as instruções de preparação.
No modo de exibição explorador do Visual Studio Code, expanda a pasta Starter e selecione Program.cs.

Quando você seleciona o arquivo Program.cs, o conteúdo do arquivo é aberto na área principal do Editor à direita do modo de exibição EXPLORER.

Se o modo de exibição EXPLORER não estiver aberto, você poderá abri-lo usando a Barra de Atividades no lado esquerdo da janela do Visual Studio Code. O botão EXPLORER é o ícone superior na Barra de Atividades.
Reserve alguns minutos para examinar o código no arquivo Program.cs.
Observe que a parte superior do código começa com algumas declarações de variáveis.
```
// initialize variables - graded assignments 
int currentAssignments = 5;

int sophia1 = 90;
int sophia2 = 86;
int sophia3 = 87;
int sophia4 = 98;
int sophia5 = 100;

int andrew1 = 92;
int andrew2 = 89;
int andrew3 = 81;
int andrew4 = 96;
int andrew5 = 90;

int emma1 = 90;
int emma2 = 85;
int emma3 = 87;
int emma4 = 98;
int emma5 = 68;

int logan1 = 90;
int logan2 = 95;
int logan3 = 87;
int logan4 = 88;
int logan5 = 96;
```
Em seguida, você verá uma linha de comentário seguida por uma lista de variáveis que são usadas para manter as notas de tarefa pontuadas de cada aluno. Sua primeira variável currentAssignments é usada para conter o número de exames aos quais foram atribuídas notas.

As variáveis de nota de tarefa representam uma ótima oportunidade para criar e usar matrizes!
Role para baixo e examine os dois grupos de linhas de código de declaração de variável.
```
int sophiaSum = 0;
int andrewSum = 0;
int emmaSum = 0;
int loganSum = 0;

decimal sophiaScore;
decimal andrewScore;
decimal emmaScore;
decimal loganScore;
```
O primeiro grupo de variáveis são inteiros que estão sendo usados para conter a soma das notas de exame.

O segundo grupo de variáveis são decimais usados para manter a nota média calculada. O código usa decimais aqui porque um cálculo de inteiro arredonda a parte fracionária do valor calculado.

Observe que você estava usando uma variável exclusiva para cada aluno. Isso talvez crie outra oportunidade para reduzir o número de linhas de código em seu aplicativo atualizado.

Parece que o código inicial começa cálculos de nota em seguida.

Role para baixo um pouco mais e reserve um minuto para examinar o seguinte código:

sophiaSum = sophia1 + sophia2 + sophia3 + sophia4 + sophia5;
andrewSum = andrew1 + andrew2 + andrew3 + andrew4 + andrew5;
emmaSum = emma1 + emma2 + emma3 + emma4 + emma5;
loganSum = logan1 + logan2 + logan3 + logan4 + logan5;

sophiaScore = (decimal)sophiaSum / currentAssignments;
andrewScore = (decimal)andrewSum / currentAssignments;
emmaScore = (decimal)emmaSum / currentAssignments;
loganScore = (decimal)loganSum / currentAssignments;

O primeiro grupo de equações é usado para calcular a soma das notas de tarefa de cada aluno.

O segundo grupo de equações calcula a nota média. Observe que o numerador é convertido em decimal para garantir que a divisão mantenha o componente fracionário.

Reserve um minuto para examinar a seção de código final:
```
Console.WriteLine("Student\t\tGrade\n");
Console.WriteLine("Sophia:\t\t" + sophiaScore + "\tA-");
Console.WriteLine("Andrew:\t\t" + andrewScore + "\tB+");
Console.WriteLine("Emma:\t\t" + emmaScore + "\tB");
Console.WriteLine("Logan:\t\t" + loganScore + "\tA-");

Console.WriteLine("Press the Enter key to continue");
Console.ReadLine();
```
Esta seção imprime a saída formatada de acordo com as diretrizes do professor. A primeira linha é uma linha de cabeçalho com títulos de coluna, seguida pelos nomes e notas de cada aluno.

A Console.ReadLine() instrução pausa o aplicativo para que o usuário do aplicativo possa examinar a saída.
No modo de exibição explorador do Visual Studio Code, clique com o botão direito do mouse em Starter e, em seguida, selecione Abrir no Terminal Integrado.

Você está usando o painel TERMINAL para executar comandos da CLI (Interface de Linha de Comando) do .NET, como dotnet build e dotnet run. O comando dotnet build compila o código e exibe mensagens de erro e de aviso relacionadas à sintaxe do código.

Importante

Verifique se o prompt de comando do terminal está aberto na raiz do workspace do projeto. Nesse caso, a raiz do workspace do projeto é a pasta Inicial, em que os arquivos Starter.csproj e Program.cs estão localizados. Quando você executa comandos da CLI do .NET no terminal, os comandos tentam executar ações usando o local da pasta atual. Se você tentar executar os comandos dotnet build ou dotnet run a partir de um local de pasta que não contém seus arquivos, os comandos gerarão mensagens de erro.
No prompt de comando TERMINAL, para compilar o código do projeto, insira o seguinte comando: dotnet build

Após alguns segundos, você verá uma mensagem informando que o build foi bem-sucedido e que você tem 0 Aviso(s) e 0 Erro(s).
```
Determining projects to restore...
All projects are up-to-date for restore.
Starter -> C:\Users\someuser\Desktop\GuidedProject\Starter\bin\Debug\net10.0\Starter.dll

Build succeeded.
    0 Warning(s)
    0 Error(s)
```
Usar comandos da CLI do .NET é uma forma fácil de compilar e executar seus aplicativos no Visual Studio Code.
No prompt de comando do Terminal, digite dotnet run e pressione Enter.

O dotnet run comando instrui o compilador a criar seu aplicativo e, desde que não haja erros de build, ele executa o código compilado.

Importante

O projeto Starter tem como destino o .NET 10 (no arquivo Starter.csproj). Se você não tiver o .NET 10 instalado, o dotnet run comando gerará um erro. Você pode instalar o SDK do .NET 10 (recomendado) ou alterar a estrutura de destino no arquivo Starter.csproj para se alinhar à versão do .NET instalada em seu ambiente.

Verifique se o seu aplicativo produziu as seguintes saídas:

Student         Grade

Sophia:         92.2    A-
Andrew:         89.6    B+
Emma:           85.6    B
Logan:          91.2    A-
Press the Enter key to continue

No painel TERMINAL, pressione a tecla Enter.

Seu aplicativo foi essencialmente pausado depois de escrever "Pressione a tecla Enter para continuar" no console. Esse comportamento é causado pela instrução Console.ReadLine(), que é usada para coletar a entrada do usuário em um aplicativo de console. Seu aplicativo deixará de ser executado quando você pressionar Enter.
Feche o painel do terminal.

Isso conclui seu exame de código. Esse aplicativo parece ser a oportunidade perfeita para aplicar matrizes, iterações e instruções de seleção.

É hora de começar a usar suas atualizações!

Criar as matrizes de notas de tarefa

Nesta tarefa, você substituirá as variáveis que contêm as notas individuais por matrizes que contêm as notas de tarefa pontuadas de cada aluno.

No Editor do Visual Studio Code, role até a parte superior do arquivo Program.cs.
Crie uma linha de código em branco abaixo da linha usada para declarar a variável currentAssignments.
Na nova linha de código, para criar uma matriz de inteiros que será usada para as notas de tarefa de Sophia, insira o seguinte código:
```
int[] sophiaScores = new int[5];
```
Observe que esse código usa o operador new para especificar que você está criando uma instância de uma matriz. O conjunto de colchetes em int[] informa ao compilador que sophiaScores será uma matriz de inteiros, enquanto o conjunto de colchetes em int[5] é usado para especificar o número de elementos na matriz.

Você talvez se lembre de que tem a opção de atribuir valores de matriz como parte da declaração.

Observação

Em situações em que você sabe os valores dos elementos de matriz antecipadamente e quando é improvável que os valores sejam alterados, faz sentido atribuir os valores da matriz quando ela é declarada. Um bom exemplo seria uma matriz usada para conter os dias da semana. Obviamente, se os valores da matriz forem desconhecidos, você não poderá especificá-los quando ela for declarada e usará a sintaxe inserida acima para declarar sua matriz.
Para especificar as notas de tarefa de Sophia dentro da declaração, atualize a declaração para sophiaScores da seguinte maneira:
```
int[] sophiaScores = new int[] { 90, 86, 87, 98, 100 };
```
Observe que o 5 usado para especificar o número de elementos foi removido e, em vez disso, você incluiu as notas das cinco tarefas pontuadas.
Verifique se as notas listadas dentro da {} correspondem às notas individuais das tarefas de Sophia.

As cinco variáveis usadas para manter notas individuais são as seguintes:
```
int sophia1 = 90;
int sophia2 = 86;
int sophia3 = 87;
int sophia4 = 98;
int sophia5 = 100;
```
Exclua as linhas de código que declaram as variáveis que contêm as notas individuais de Sophia.

Como você usará a matriz sophiaScores para acessar as notas de Sophia daqui para frente, essas variáveis não são mais necessárias.
Para criar uma matriz de inteiros que será usada para as notas das tarefas de Andrew, insira o seguinte código:
```
int[] andrewScores = new int[] {92, 89, 81, 96, 90};
```
Crie as declarações de matrizes para os outros alunos.

Certifique-se de nomear as matrizes usando o nome do aluno e copie os valores de suas notas individuais para {} na linha de declaração da matriz.
Verifique se você copiou as notas individuais para as declarações de matriz com precisão e exclua as variáveis usadas para manter as notas individuais de Andrew, Emma e Logan.

O código na parte superior do arquivo Program.cs agora deve ser semelhante ao seguinte:
```
// initialize variables - graded assignments 
int currentAssignments = 5;

int[] sophiaScores = new int[] { 90, 86, 87, 98, 100 };
int[] andrewScores = new int[] { 92, 89, 81, 96, 90 };
int[] emmaScores = new int[] { 90, 85, 87, 98, 68 };
int[] loganScores = new int[] { 90, 95, 87, 88, 96 };

int sophiaSum = 0;
```
Bom trabalho! As matrizes de notas estão declaradas e prontas para uso.

Criar uma iteração foreach para calcular a nota de Sophia

Nesta tarefa, você substituirá o código existente usado para executar cálculos por uma instrução foreach iterada por meio das notas de tarefa de Sophia. Você usará o bloco de código do loop foreach para calcular a soma das notas da Sophia e calcular e exibir a nota de Sophia.

Localize as linhas de código que são usadas para declarar variáveis e executar cálculos para os valores de soma e nota média.

A aparência do código deve ser semelhante ao seguinte:

int sophiaSum = 0;
int andrewSum = 0;
int emmaSum = 0;
int loganSum = 0;

decimal sophiaScore;
decimal andrewScore;
decimal emmaScore;
decimal loganScore;

sophiaSum = sophia1 + sophia2 + sophia3 + sophia4 + sophia5;
andrewSum = andrew1 + andrew2 + andrew3 + andrew4 + andrew5;
emmaSum = emma1 + emma2 + emma3 + emma4 + emma5;
loganSum = logan1 + logan2 + logan3 + logan4 + logan5;

sophiaScore = (decimal)sophiaSum / currentAssignments;
andrewScore = (decimal)andrewSum / currentAssignments;
emmaScore = (decimal)emmaSum / currentAssignments;
loganScore = (decimal)loganSum / currentAssignments;

Exclua as linhas de código usadas para executar os cálculos de soma.

Você escreverá o código para calcular a soma dentro de um loop foreach quando terminar de limpar.
Exclua as linhas de código que declaram variáveis int e decimal para Andrew, Emma e Logan.

Observação

Deixe as linhas de código que declaram variáveis para Sophia.
Exclua as linhas de código usadas para calcular a nota média de Andrew, Emma e Logan.

Observação

Deixe a linha de código que contém o cálculo de nota média para Sophia.
Role para baixo até a parte inferior do código e exclua as linhas de código usadas para relatar notas para Andrew, Emma e Logan.

Verifique se o arquivo atualizado Program.cs contém o seguinte código:

Observação

Adicione ou remova linhas de código em branco para que seu código corresponda ao código mostrado abaixo.

// initialize variables - graded assignments 
int currentAssignments = 5;

int[] sophiaScores = new int[] { 90, 86, 87, 98, 100 };
int[] andrewScores = new int[] { 92, 89, 81, 96, 90 };
int[] emmaScores = new int[] { 90, 85, 87, 98, 68 };
int[] loganScores = new int[] { 90, 95, 87, 88, 96 };

int sophiaSum = 0;

decimal sophiaScore;

sophiaScore = (decimal)sophiaSum / currentAssignments;

Console.WriteLine("Student\t\tGrade\n");
Console.WriteLine("Sophia:\t\t" + sophiaScore + "\tA-");

Console.WriteLine("Press the Enter key to continue");
Console.ReadLine();

Crie uma linha de código em branco após a linha usada para declarar sophiaScore.
Para criar uma instrução foreach que você usará para fazer a iteração por meio das notas de Sophia, insira o seguinte código:
```
foreach (int score in sophiaScores)
{
}
```
Observe que esse código cria uma instância de uma variável de inteiro chamada score como parte da instrução foreach . Você usará score dentro do bloco de código do para foreach acessar os valores da matriz sophiaScores.
Para criar a equação que soma a nota de Sophia, atualize o bloco de código foreach da seguinte maneira:
```
foreach (int score in sophiaScores)
{
    // add the exam score to the sum
    sophiaSum += score;    
}
```
Observe que esse código está usando o operador += para adicionar o valor de score para sophiaSum dentro do loop foreach. Os desenvolvedores geralmente usam += como um atalho ao calcular uma soma. Essa equação é equivalente ao seguinte:
```
sophiaSum = sophiaSum + score;
```
Depois que o loop foreach tiver sido iterado por meio de todos os valores na matriz sophiaScores, sophiaSum conterá a soma de suas pontuações.

Reserve um momento para examinar seu código.

Agora, seu código deve ser semelhante ao seguinte:

// initialize variables - graded assignments 
int currentAssignments = 5;

int[] sophiaScores = new int[] { 90, 86, 87, 98, 100 };
int[] andrewScores = new int[] { 92, 89, 81, 96, 90 };
int[] emmaScores = new int[] { 90, 85, 87, 98, 68 };
int[] loganScores = new int[] { 90, 95, 87, 88, 96 };

int sophiaSum = 0;

decimal sophiaScore;

foreach (int score in sophiaScores)
{
    // add the exam score to the sum
    sophiaSum += score;
}

sophiaScore = (decimal)sophiaSum / currentAssignments;

Console.WriteLine("Student\t\tGrade\n");
Console.WriteLine("Sophia:\t\t" + sophiaScore + "\tA-");

Console.WriteLine("Press the Enter key to continue");
Console.ReadLine();

Neste ponto, você criou as matrizes de notas para todos os alunos e está calculando a soma da nota de Sophia dentro de um loop foreach iterado por meio das suas notas. Você ainda tem um longo caminho a percorrer para concluir todas as atualizações planejadas, mas esse é um bom ponto para marcar seu progresso.

No menu Arquivo do Visual Studio Code, clique em Salvar.

Verificar seu trabalho

Nesta tarefa, você executará o aplicativo para verificar se a lógica do código está funcionando conforme o esperado.

Verifique se você salvou as alterações no arquivo Program.cs.
No modo de exibição explorador do Visual Studio Code, clique com o botão direito do mouse em Starter e, em seguida, selecione Abrir no Terminal Integrado.

Você usará o painel Terminal para inserir comandos da CLI do .NET que criam e executam seus aplicativos.
Verifique se o prompt de comando do Terminal lista a pasta Inicial como o local da pasta atual.

Você verá um prompt de comando semelhante ao seguinte:
```
C:\Users\someuser\Desktop\GuidedProject\Starter>
```
No prompt de comando TERMINAL, para compilar o código do projeto, insira o seguinte comando: dotnet build

Após alguns segundos, você verá uma mensagem informando que o build foi bem-sucedido e que você tem 0 Aviso(s) e 0 Erro(s).
```
Determining projects to restore...
All projects are up-to-date for restore.
Starter -> C:\Users\someuser\Desktop\GuidedProject\Starter\bin\Debug\net10.0\Starter.dll

Build succeeded.
    0 Warning(s)
    0 Error(s)
```
Se você vir mensagens de Aviso ou Erro, precisará corrigi-las antes de continuar.

Mensagens de Aviso e Erro listam a linha de código em que o problema pode ser encontrado. Este é um exemplo de uma mensagem de erro Build FAILED:

C:\Users\someuser\Desktop\GuidedProject\Starter\Program.cs(53,18): error CS1002: ; expected [C:\Users\someuser\Desktop\GuidedProject\Starter\Starter.csproj]

Esta mensagem informa o tipo de erro detectado e onde encontrá-lo. Nesse caso, a mensagem informa que o arquivo Program.cs contém um erro: error CS1002: ; expected. O ; expected sugere que o desenvolvedor esqueceu de incluir um ; no final de uma instrução. A parte Program.cs(53,18) da mensagem informa que o erro está localizado na linha de código 53, na posição 18 caracteres a partir da esquerda.

Um erro de sintaxe como esse impede que a tarefa Build seja bem-sucedida (FALHA no Build). Algumas mensagens de Build apresentam um "Aviso" em vez de "Erro", o que significa que há algo com o que se preocupar, mas você pode tentar executar o programa de qualquer maneira (Build bem-sucedido).

Depois de corrigir os problemas e salvar as atualizações, você poderá executar o comando dotnet build novamente. Continue atualizando e salvando seu código até que você tenha 0 Aviso(s) e 0 Erro(s).

Observação

Se você tiver problemas para resolver um problema por conta própria, poderá examinar o código Program.cs na pasta Final incluída como parte do download que você concluiu durante a Preparação. O código Program.cs na pasta Final representa a conclusão de todos os exercícios neste módulo. Portanto, ele incluirá o código que você ainda não criou. Ele talvez pareça consideravelmente diferente do código Program.cs que você desenvolveu neste ponto no projeto guiado. No entanto, você pode tentar examinar o código Program.cs em Final para ajudar você a isolar e corrigir um problema em seu código, se necessário. Tente não usar o código na pasta Final como um guia se você puder evitar. Lembre-se de que você aprende com seus erros e que todo desenvolvedor gasta tempo encontrando e corrigindo erros.
No prompt de comando do Terminal, digite dotnet run e pressione Enter.

O comando dotnet run instrui o compilador a criar seu aplicativo e, desde que nenhum erro seja detectado, executar o código compilado.

Verifique se o código produziu a seguinte saída:

Student         Grade

Sophia:         92.2    A-
Press the Enter key to continue

No painel “TERMINAL”, para interromper a execução do aplicativo, pressione a tecla Enter.
Feche o painel do terminal.

Parabéns! Você criou um aplicativo que usa um loop foreach para ser iterado por meio dos elementos de uma matriz e executar cálculos com base no conteúdo da matriz. Você está fazendo um grande progresso nas atualizações de aplicativo necessárias!

Comentários

Esta página foi útil?