Sua dose diária de programação

Conceito, 3 exemplos e 3 exercícios: uma pequena conquista de cada vez.

✦   Lição

Seu primeiro programa

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.

C# Fundamentos Iniciante 3 exemplos + 3 exercícios
42 lições publicadas 10 linguagens novas lições todo dia útil
C# / Fundamentos

Seu primeiro programa

por Briar Westbrook
Iniciante

Entenda 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ê.

↳ Pontos-chave
  • Console.WriteLine("texto"); escreve o texto e pula para a próxima linha; sem argumento, imprime uma linha em branco.
  • Console.Write escreve 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.writeline não compila.
  • Com top-level statements o arquivo pode ter só as instruções; a forma tradicional usa class Program com static void Main().
  • Dentro das aspas, \n quebra a linha, \t tabula 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

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

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

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

↳ Requisitos
  • 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.
código inicial
// Cartão de leitor da biblioteca
Console.WriteLine("Biblioteca Municipal");
// escreva as outras três linhas abaixo
saída esperada
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

  1. A primeira linha é um comentário com //: o compilador ignora e ela só explica o que o programa faz.
  2. Console.WriteLine("Biblioteca Municipal"); escreve o cabeçalho do cartão e pula para a linha seguinte.
  3. As três chamadas seguintes seguem o mesmo padrão, cada uma com o seu texto entre aspas duplas.
  4. O número 2 e a data 20/10 estão dentro do texto, então são impressos exatamente como foram digitados.
  5. 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.

↳ Requisitos
  • Cada linha de time deve usar um Console.Write para o nome e um Console.WriteLine com 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 \t e \n.
  • A saída deve ser idêntica à esperada, com uma tabulação depois de Rodadas: e de Vencedor:.
código inicial
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
saída esperada
=== 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

  1. Console.WriteLine("=== Placar Final ==="); imprime o título e já pula para a linha seguinte.
  2. 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.
  3. Console.WriteLine(3); recebe um número, converte em texto e termina a linha, formando Time Azul: 3.
  4. O mesmo par de chamadas monta a linha do Time Verde.
  5. No último WriteLine, \t insere uma tabulação e \n quebra 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 WriteLine para o nome: Console.WriteLine("Time Azul: "); seguido de Console.WriteLine(3); coloca o 3 sozinho na linha de baixo. Use Write na primeira parte.
  • Esquecer o espaço: Console.Write("Time Azul:"); gera Time Azul:3, que é diferente da saída esperada. Deixe o espaço dentro das aspas.
  • Escrever a barra ao contrário: "Rodadas:/t5" imprime /t literalmente. 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).

↳ Requisitos
  • Não usar top-level statements: o código fica dentro de static void Main() na classe Program, no namespace Loja.
  • 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..
código inicial
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
    }
}
saída esperada
****************************
*   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

  1. namespace Loja; é a declaração com escopo de arquivo (C# 10+): tudo o que vem depois pertence ao namespace Loja, sem precisar de chaves extras.
  2. class Program agrupa o código, e static void Main() é o ponto de entrada: o .NET chama esse método ao iniciar o programa.
  3. string borda = new string('*', 28); cria um texto com o caractere * repetido 28 vezes. Note as aspas simples: o primeiro argumento é um char.
  4. Guardar a borda numa variável evita digitar 28 asteriscos duas vezes e garante que as bordas de cima e de baixo sejam iguais.
  5. 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.
  6. 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 um char. Use '*'.
  • Misturar as duas formas: deixar um Console.WriteLine solto no topo do arquivo, fora do namespace, e manter a class Program gera o erro CS0260, porque o compilador já cria uma classe Program para 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étodo Main está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.

Últimas lições

Ver o arquivo completo →