C# Sobre os Projetos

Nas aulas, cada página ensina um assunto. Nos projetos, você junta vários assuntos para construir um programa inteiro, do arquivo vazio até a versão final. É aqui que as peças se encaixam: o Console.ReadLine conversa com o TryParse, que alimenta um switch, que chama um método que você mesmo escreveu.

A ideia: montar um móvel seguindo o manual

Quem monta um armário não aparafusa todas as peças de uma vez para só no fim descobrir que a porta ficou torta. O manual divide em passos: primeiro a base, depois as laterais, confere se está firme, depois as prateleiras. Ao fim de cada passo, o que já foi montado fica de pé.

Os projetos do guia são iguais. Cada um é dividido em versões (versão 1, 2, 3…), e cada versão acrescenta uma coisa nova à anterior. No fim de toda versão, o programa compila e roda. Você nunca fica com um monte de código "que ainda não funciona".

Toda página de projeto segue o mesmo roteiro:

1. O que vamos construir. Uma sessão real do programa pronto, para você ver aonde vai chegar.
2. Antes de começar. As aulas que você precisa ter visto e a pasta onde o projeto vai morar.
3. As versões. Cada uma mostra o código, explica o que mudou, mostra a saída real (rodada com o .NET 10 na máquina da Ana) e termina com uma caixa Experimente em que você faz a parte nova.
4. Quando dá errado. Os erros que aparecem de verdade naquele projeto, com a mensagem completa e o conserto.
5. O programa completo e os desafios. A versão final, inteira, e ideias para você continuar sozinho.

Os projetos

Estão em ordem de dificuldade. Os primeiros usam o Nível 1 e um pouco de métodos; os últimos pedem classes, coleções, arquivos e LINQ.

Onde rodar: duas formas

1. No editor do guia (o mais fácil)

Toda versão tem uma caixa Experimente com o código da versão anterior. Você edita, clica em Rodar e vê a saída. O editor usa o compilador C# de verdade, o mesmo do dotnet, e roda o programa dentro do navegador (veja O Editor do Guia).

Quase todo projeto lê o teclado com Console.ReadLine(). Nas missões, a entrada já vem pronta, no campo Entrada abaixo do editor (o texto da missão diz qual é), e o programa a lê como se você tivesse digitado. Repare que, como ninguém digitou de verdade, as respostas não aparecem na saída: as perguntas ficam grudadas umas nas outras (Primeiro número: Segundo número: …). Nas caixas sem entrada pronta, você mesmo digita: quando o programa pergunta, aparece um campo no terminal da caixa, logo depois da pergunta. Digite e tecle Enter (Ctrl+D encerra a entrada, e o ReadLine() devolve null). Aí, sim, o que você digitou aparece ao lado da pergunta, como no terminal.

Experimente agora. Este é o "esqueleto" de todo projeto: uma linha com o título do programa.

Console.WriteLine("=== Título ===");

Console.WriteLine("=== Meu Primeiro Projeto ===");

2. No terminal do seu computador

Para guardar o seu trabalho, cada projeto ganha uma pasta. Os três primeiros (calculadora, adivinhação e boletim) são um arquivo só, e a Ana roda com dotnet run arquivo.cs, como aprendeu em Rodar com dotnet run. Esta é a primeira versão da calculadora:

$ mkdir -p cs/calculadora              « cria a pasta do projeto (e a cs, se não existir)
$ cd cs/calculadora
$ ls
calculadora.cs                         « o arquivo que a Ana escreveu no editor
$ dotnet run calculadora.cs
=== Calculadora da Ana ===
Primeiro número: 10                    « 10 e 5 foram digitados pela Ana
Segundo número: 5
10 + 5 = 15

Os projetos maiores (agenda, banco, estoque e tarefas) têm vários arquivos ou usam recursos que pedem um projeto de verdade, com o arquivo .csproj. A Ana cria cada um com dotnet new console (veja Projetos) e roda com dotnet run, sem nome de arquivo:

$ mkdir -p projetos
$ cd projetos
$ dotnet new console -o Agenda
O modelo "Aplicativo do Console" foi criado com êxito.

Processando ações pós-criação...
Restaurando /home/ana/projetos/Agenda/Agenda.csproj:
  Determinando os projetos a serem restaurados...
  /home/ana/projetos/Agenda/Agenda.csproj restaurado (em 104 ms).
A restauração foi bem-sucedida.

$ cd Agenda
$ ls
Agenda.csproj  obj  Program.cs
$ dotnet run                           « compila todos os .cs da pasta e roda

Entrada de um arquivo: sem digitar tudo de novo

Testar a calculadora dez vezes é digitar dez vezes os mesmos números. Em vez disso, a Ana guardou a entrada num arquivo de texto e mandou o arquivo para o programa com < (é o mesmo que a caixa Experimente faz com a entrada da missão). Como ninguém digitou, os números não aparecem depois das perguntas:

$ cat entrada.txt
10
5
$ dotnet run calculadora.cs < entrada.txt
=== Calculadora da Ana ===
Primeiro número: Segundo número: 10 + 5 = 15

Como estudar um projeto

1. Leia a versão inteira antes de digitar. Entenda o que muda e por quê.
2. Digite o código, não copie e cole. Parece mais lento, mas é digitando que você erra, lê a mensagem do compilador e aprende a consertar.
3. Rode depois de cada versão e compare com a saída da página. Se for diferente, ache a diferença antes de seguir.
4. Mude alguma coisa. Troque uma mensagem, um número, uma condição, e tente prever o que vai acontecer antes de rodar.
5. Só então vá para a próxima versão.

Console.Write("Seu nome: ");
string nome = Console.ReadLine() ?? "";
console.WriteLine($"Olá, {nome}! Vamos programar.")

$ dotnet run ola.cs
/home/ana/cs/ola/ola.cs(3,52): error CS1002: ; esperado

Ocorreu uma falha no build. Corrija os erros de build e execute novamente.

$ dotnet run ola.cs
/home/ana/cs/ola/ola.cs(3,1): error CS0103: O nome "console" não existe no contexto atual

Ocorreu uma falha no build. Corrija os erros de build e execute novamente.

Para aquecer, um programa que lê do teclado, como quase todos os projetos fazem. A entrada Ana já vem pronta na missão.

Console.Write("Seu nome: ");
string nome = Console.ReadLine() ?? "";
// escreva aqui a saudação

Console.Write("Seu nome: ");
string nome = Console.ReadLine() ?? "";
Console.WriteLine($"Olá, {nome}! Vamos programar.");

$ dotnet run ola.cs
Seu nome: Ana
Olá, Ana! Vamos programar.

Exercícios

Resumo

• Cada projeto é construído em versões; ao fim de cada uma, o programa compila e roda.
• Toda página de projeto tem: o resultado final, os pré-requisitos, as versões com missões, os erros reais e os desafios.
• Calculadora, adivinhação e boletim são um arquivo só: dotnet run arquivo.cs. Agenda, banco, estoque e tarefas são projetos: dotnet new console -o Nome e dotnet run.
• dotnet run arquivo.cs < entrada.txt manda a entrada de um arquivo, como as missões do editor.
• Quando der erro, leia a primeira mensagem: arquivo, linha, coluna e código CS….

Comece pelo primeiro: Calculadora.