Seu primeiro programa
por Briar WestbrookEntenda o conceito
Todo programa em C# é uma sequência de instruções que o computador executa de cima para baixo. A mais usada no começo é Console.WriteLine, que escreve um texto no terminal e pula para a linha seguinte. Cada instrução termina com ponto e vírgula (;), e textos ficam entre aspas duplas.
Desde o C# 9 existem os top-level statements: você escreve as instruções soltas no arquivo, sem declarar classe nem método Main. O compilador cria essa estrutura por baixo. No .NET 10, um arquivo .cs sozinho roda com dotnet run arquivo.cs; em versões anteriores, o código vai no Program.cs de um projeto criado com dotnet new console.
Além de WriteLine, vale conhecer Console.Write (escreve sem quebrar a linha), as sequências de escape (\n, \t, \") e os comentários (// e /* ... */), que o compilador ignora e servem para explicar o código a quem lê.
Console.WriteLine("texto");escreve o texto e pula para a próxima linha; sem argumento, imprime uma linha em branco.Console.Writeescreve sem quebrar a linha, então o próximo texto continua logo depois.- Toda instrução termina com
;e o C# diferencia maiúsculas de minúsculas:console.writelinenão compila. - Com top-level statements o arquivo pode ter só as instruções; a forma tradicional usa
class Programcomstatic void Main(). - Dentro das aspas,
\nquebra a linha,\ttabula e\"escreve aspas; com@"..."a barra invertida vale literalmente.
Do conceito à prática
3 exemplos para ver a ideia funcionando.
01Olá, C#: WriteLine e comentários
// Meu primeiro programa em C#: o boletim de boas-vindas da escola.
// Com top-level statements, as instruções ficam soltas no arquivo,
// sem classe nem método Main escritos à mão.
// WriteLine escreve o texto e pula para a próxima linha
Console.WriteLine("Olá, C#!");
Console.WriteLine("Bem-vindo ao boletim da turma 7A.");
// Uma chamada sem argumento imprime uma linha em branco
Console.WriteLine();
/* Comentário de bloco: pode ocupar
várias linhas e o compilador ignora tudo aqui dentro. */
Console.WriteLine("Disciplinas do bimestre:");
Console.WriteLine("- Matemática");
Console.WriteLine("- Português");
Console.WriteLine("- Ciências");
Console.WriteLine();
Console.WriteLine("Fim do programa.");
O programa mais simples possível: uma lista de Console.WriteLine, executadas na ordem em que aparecem. A chamada sem argumento, Console.WriteLine(), imprime uma linha vazia e ajuda a separar blocos da saída.
Os comentários de linha (//) e de bloco (/* ... */) não aparecem na saída: servem só para quem lê o código. Repare que não há classe nem Main; graças aos top-level statements, o arquivo começa direto pelas instruções.
02Ficha de receita: Write, WriteLine e escapes
// Ficha de receita: Write continua na mesma linha, WriteLine quebra a linha.
Console.WriteLine("Receita: Bolo de cenoura");
// Write não pula linha; o próximo texto continua logo depois
Console.Write("Porções: ");
Console.WriteLine(8);
Console.Write("Tempo de forno: ");
Console.Write(40);
Console.WriteLine(" minutos");
Console.WriteLine();
// Sequências de escape dentro das aspas:
// \n quebra a linha, \t insere uma tabulação, \" escreve aspas
Console.WriteLine("Ingredientes:\n\t3 cenouras\n\t4 ovos\n\t2 xícaras de farinha");
Console.WriteLine("Dica da vovó: \"não abra o forno antes de 30 minutos\"");
// Texto literal com @: a barra invertida não vira escape
Console.WriteLine(@"Arquivo salvo em C:\receitas\bolo.txt");
Console.Write deixa o cursor na mesma linha, por isso Write("Porções: ") seguido de WriteLine(8) gera uma única linha Porções: 8. Os dois métodos também aceitam números, que são convertidos em texto automaticamente.
As sequências de escape permitem colocar quebras de linha, tabulações e aspas dentro de um único texto. Já o texto com @ (verbatim) trata a barra invertida como caractere comum, o que é prático para caminhos do Windows.
03Inventário do jogo na forma tradicional com Main
// Inventário do jogo na forma tradicional: namespace, classe e Main.
// É o que o compilador gera por baixo dos top-level statements.
namespace JogoDeAventura;
class Program
{
// Main é o ponto de entrada: o programa começa aqui
static void Main()
{
Console.WriteLine("=== Inventário do Herói ===");
MostrarItem("Espada", 1);
MostrarItem("Poção de vida", 3);
MostrarItem("Moeda de ouro", 120);
Console.WriteLine("===========================");
Console.WriteLine("Boa sorte na masmorra!");
}
// Método auxiliar: cada chamada imprime uma linha do inventário
static void MostrarItem(string nome, int quantidade)
{
Console.Write(nome);
Console.Write(": ");
Console.WriteLine(quantidade);
}
}
Esta é a estrutura que os top-level statements escondem: um namespace, uma classe Program e o método static void Main(), que é o ponto de entrada do programa. Você vai encontrar essa forma em muitos projetos e tutoriais mais antigos.
O método auxiliar MostrarItem recebe o nome e a quantidade e imprime uma linha do inventário. Assim, cada item novo custa uma única linha em Main, em vez de três chamadas repetidas.
Agora é com você
Tente resolver no rascunho antes de abrir a resposta. Os códigos não são executados nesta página.
01Cartão de leitor da bibliotecaFácil
Escreva um programa que imprima o cartão de um leitor da biblioteca, com uma informação por linha: o nome da biblioteca, o nome do leitor, a quantidade de livros emprestados e a data de devolução.
- Usar top-level statements, sem declarar classe nem
Main. - Usar exatamente quatro chamadas a
Console.WriteLine, uma por linha da saída. - A saída deve ser idêntica à esperada, inclusive acentos e dois-pontos.
// Cartão de leitor da biblioteca
Console.WriteLine("Biblioteca Municipal");
// escreva as outras três linhas abaixo
Biblioteca Municipal
Leitor: Ana Souza
Livros emprestados: 2
Devolução até: 20/10
Ver dica
Cada linha da saída corresponde a uma instrução Console.WriteLine("...");. Não esqueça o ponto e vírgula no fim de cada uma.
Ver resposta
// Cartão de leitor da biblioteca: uma informação por linha
Console.WriteLine("Biblioteca Municipal");
Console.WriteLine("Leitor: Ana Souza");
Console.WriteLine("Livros emprestados: 2");
Console.WriteLine("Devolução até: 20/10");
Passo a passo
- A primeira linha é um comentário com
//: o compilador ignora e ela só explica o que o programa faz. Console.WriteLine("Biblioteca Municipal");escreve o cabeçalho do cartão e pula para a linha seguinte.- As três chamadas seguintes seguem o mesmo padrão, cada uma com o seu texto entre aspas duplas.
- O número
2e a data20/10estão dentro do texto, então são impressos exatamente como foram digitados. - Não há classe nem
Main: com top-level statements, o compilador gera essa estrutura sozinho.
Por que funciona
As instruções de um programa C# são executadas na ordem em que aparecem. Como WriteLine sempre termina a linha atual, quatro chamadas produzem exatamente quatro linhas, cada uma com uma informação do cartão.
Erros comuns
- Esquecer o ponto e vírgula:
Console.WriteLine("Leitor: Ana Souza")sem;gera o erro de compilação; expected. Coloque o;no fim de cada instrução. - Trocar a caixa das letras:
console.writeline("...")não compila, porque C# diferencia maiúsculas de minúsculas. O certo éConsole.WriteLine. - Usar aspas simples:
Console.WriteLine('Leitor');falha, pois aspas simples são para um único caractere (char). Textos usam aspas duplas.
Outra forma de resolver
Dá para gerar as quatro linhas com uma única chamada, usando \n dentro do texto: Console.WriteLine("Biblioteca Municipal\nLeitor: Ana Souza\nLivros emprestados: 2\nDevolução até: 20/10");. Funciona, mas fica mais difícil de ler; prefira chamadas separadas quando cada linha é uma informação diferente.
Saída esperada
Biblioteca Municipal
Leitor: Ana Souza
Livros emprestados: 2
Devolução até: 20/10
02Placar final da partidaMédio
Monte o placar final de uma partida combinando Console.Write e Console.WriteLine para escrever o nome de cada time e os pontos na mesma linha. No fim, use um único WriteLine com \t e \n para mostrar o número de rodadas e o vencedor em duas linhas.
- Cada linha de time deve usar um
Console.Writepara o nome e umConsole.WriteLinecom o número de pontos (3 e 1) como argumento numérico. - As linhas de rodadas e vencedor devem sair de uma única chamada a
Console.WriteLine, usando\te\n. - A saída deve ser idêntica à esperada, com uma tabulação depois de
Rodadas:e deVencedor:.
Console.WriteLine("=== Placar Final ===");
// Time Azul: use Write para o nome e WriteLine para os pontos
// Time Verde: idem
// Rodadas e vencedor em uma única chamada, com \t e \n
=== Placar Final ===
Time Azul: 3
Time Verde: 1
Rodadas: 5
Vencedor: Azul
Ver dica
Console.Write não muda de linha: o que vier no próximo WriteLine aparece logo depois, na mesma linha. Lembre do espaço depois dos dois-pontos.
Ver resposta
// Placar do jogo montado com Write (mesma linha) e WriteLine (quebra a linha)
Console.WriteLine("=== Placar Final ===");
Console.Write("Time Azul: ");
Console.WriteLine(3);
Console.Write("Time Verde: ");
Console.WriteLine(1);
// \t insere uma tabulação; \n quebra a linha dentro do texto
Console.WriteLine("Rodadas:\t5\nVencedor:\tAzul");
Passo a passo
Console.WriteLine("=== Placar Final ===");imprime o título e já pula para a linha seguinte.Console.Write("Time Azul: ");escreve o nome do time e deixa o cursor na mesma linha; o espaço final separa o nome do número.Console.WriteLine(3);recebe um número, converte em texto e termina a linha, formandoTime Azul: 3.- O mesmo par de chamadas monta a linha do Time Verde.
- No último
WriteLine,\tinsere uma tabulação e\nquebra a linha no meio do texto, gerando duas linhas com uma única chamada.
Por que funciona
Write e WriteLine escrevem no mesmo lugar: a diferença é só que WriteLine acrescenta a quebra de linha no fim. Combinando os dois, você decide onde cada linha termina. As sequências de escape fazem o mesmo papel dentro de um texto: o compilador troca \n pela quebra de linha e \t pela tabulação.
Erros comuns
- Usar
WriteLinepara o nome:Console.WriteLine("Time Azul: ");seguido deConsole.WriteLine(3);coloca o 3 sozinho na linha de baixo. UseWritena primeira parte. - Esquecer o espaço:
Console.Write("Time Azul:");geraTime Azul:3, que é diferente da saída esperada. Deixe o espaço dentro das aspas. - Escrever a barra ao contrário:
"Rodadas:/t5"imprime/tliteralmente. A sequência de escape usa a barra invertida,\t.
Outra forma de resolver
Você pode juntar texto e número numa só chamada com interpolação: Console.WriteLine($"Time Azul: {3}");. Fica mais curto e é a forma preferida quando os valores vêm de variáveis, assunto das próximas lições; aqui, o objetivo era praticar a diferença entre Write e WriteLine.
Saída esperada
=== Placar Final ===
Time Azul: 3
Time Verde: 1
Rodadas: 5
Vencedor: Azul
03Cartaz de promoção da loja com MainDesafio
Escreva, na forma tradicional com namespace, class Program e static void Main(), um programa que imprima o cartaz de promoção da loja dentro de uma moldura de asteriscos. A borda de cima e a de baixo devem vir de uma mesma variável criada com new string('*', 28).
- Não usar top-level statements: o código fica dentro de
static void Main()na classeProgram, no namespaceLoja. - Criar a borda uma única vez com
new string('*', 28)e imprimir essa mesma variável em cima e embaixo. - Todas as linhas da moldura, inclusive as bordas, devem ter exatamente 28 caracteres.
- Depois da moldura, imprimir a linha
Válida até 31/10..
namespace Loja;
class Program
{
static void Main()
{
// crie a borda com new string('*', 28)
// imprima a borda, as três linhas do cartaz, a borda e a validade
}
}
****************************
* PROMOÇÃO DE OUTUBRO *
* Camiseta: R$ 39,90 *
* Boné: R$ 24,90 *
****************************
Válida até 31/10.
Ver dica
Conte os caracteres de cada linha do cartaz, incluindo os espaços e os dois asteriscos das pontas: o total precisa dar 28, igual à borda.
Ver resposta
// Cartaz de promoção da loja na forma tradicional, com classe e Main
namespace Loja;
class Program
{
static void Main()
{
// new string('*', 28) repete o caractere 28 vezes
string borda = new string('*', 28);
Console.WriteLine(borda);
Console.WriteLine("* PROMOÇÃO DE OUTUBRO *");
Console.WriteLine("* Camiseta: R$ 39,90 *");
Console.WriteLine("* Boné: R$ 24,90 *");
Console.WriteLine(borda);
Console.WriteLine("Válida até 31/10.");
}
}
Passo a passo
namespace Loja;é a declaração com escopo de arquivo (C# 10+): tudo o que vem depois pertence ao namespaceLoja, sem precisar de chaves extras.class Programagrupa o código, estatic void Main()é o ponto de entrada: o .NET chama esse método ao iniciar o programa.string borda = new string('*', 28);cria um texto com o caractere*repetido 28 vezes. Note as aspas simples: o primeiro argumento é umchar.- Guardar a borda numa variável evita digitar 28 asteriscos duas vezes e garante que as bordas de cima e de baixo sejam iguais.
- As três linhas do meio começam e terminam com
*e têm espaços de preenchimento para chegar a 28 caracteres, alinhando a moldura. - Por fim,
Console.WriteLine("Válida até 31/10.");imprime a validade fora da moldura.
Por que funciona
A forma tradicional é exatamente o que o compilador gera quando você usa top-level statements: uma classe com um método Main estático. Escrevê-la à mão mostra de onde o programa começa. A moldura fica alinhada porque todas as linhas têm o mesmo número de caracteres, e a borda vem de uma única fonte, a variável borda.
Erros comuns
- Usar aspas duplas no caractere:
new string("*", 28)não compila, porque o construtor espera umchar. Use'*'. - Misturar as duas formas: deixar um
Console.WriteLinesolto no topo do arquivo, fora do namespace, e manter aclass Programgera o erro CS0260, porque o compilador já cria uma classeProgrampara os top-level statements. Escolha uma forma só. - Contar errado os espaços: uma linha com 27 caracteres deixa o asterisco final fora do alinhamento. Conte inclusive os asteriscos das pontas.
- Escrever
static void main()com m minúsculo: o compilador não encontra o ponto de entrada e falha com o erro CS5001 (não há métodoMainestático). O nome éMain, com M maiúsculo.
Outra forma de resolver
Com top-level statements, as mesmas instruções de Main ficariam soltas no arquivo, sem namespace, classe ou chaves. É a forma preferida para programas pequenos; a estrutura com Main aparece em projetos maiores e em código escrito antes do C# 9.
Saída esperada
****************************
* PROMOÇÃO DE OUTUBRO *
* Camiseta: R$ 39,90 *
* Boné: R$ 24,90 *
****************************
Válida até 31/10.