O Primeiro Programa, Átomo por Átomo

Chegou o momento que dá sentido a tudo o que preparamos: escrever e executar o seu primeiro programa. Por tradição, o primeiro programa que se escreve em qualquer linguagem exibe na tela a mensagem "Olá, mundo" — um ritual de iniciação que atravessa gerações de programadores. Nós o cumpriremos, mas com uma diferença que definirá o espírito deste curso: não vamos apenas digitar e ver funcionar. Vamos dissecar cada pedaço do que escrevemos, entender o que faz, e por que está ali. Um iniciante que apenas copia código aprende a copiar; um iniciante que compreende cada átomo aprende a programar. Prepare-se para digitar pouco e entender muito.

Criando o projeto

Em C#, não escrevemos um programa como um arquivo de texto solto; trabalhamos com o que se chama um projeto — uma pasta organizada com o seu código e um arquivo que descreve como o programa deve ser construído. Não se preocupe com os detalhes disso agora; a ferramenta dotnet cria tudo para você. Abra o seu terminal (o PowerShell no Windows, ou o Ubuntu se você usou WSL) e digite os comandos a seguir, um de cada vez, pressionando Enter após cada um:

dotnet new console -n OlaMundo
cd OlaMundo
dotnet run

Vamos entender o que cada linha fez. O primeiro comando, dotnet new console -n OlaMundo, pediu ao .NET que criasse um novo projeto do tipo "console" (isto é, um programa que funciona numa janela de texto, sem botões nem imagens) com o nome "OlaMundo". Isso gerou uma pasta chamada OlaMundo com os arquivos iniciais. O segundo comando, cd OlaMundo, entrou nessa pasta (cd significa "mudar de diretório", ou seja, entrar numa pasta). O terceiro, dotnet run, compilou e executou o programa. Se tudo deu certo, você viu aparecer na tela:

Hello, World!

Pare um instante e aprecie o que aconteceu: uma instrução escrita em C# foi traduzida e executada pela máquina, e produziu um efeito visível — texto na sua tela. Por mais modesto que pareça, esse é o mecanismo fundamental de todo programa que existe, do mais simples ao mais complexo. Agora vamos abrir o capô e entender o que produziu essa mensagem.

Abrindo o código

Abra a pasta OlaMundo no VS Code (você pode digitar code . no terminal, dentro da pasta — o ponto significa "a pasta atual" — ou abrir o editor e usar "Abrir pasta"). Dentro dela, encontre e abra o arquivo chamado Program.cs. A extensão .cs identifica um arquivo de código C# (o "cs" vem de "C Sharp"). Este é o arquivo que contém as instruções do seu programa. Num projeto recém-criado, o conteúdo dele é surpreendentemente curto — provavelmente uma única linha significativa:

Console.WriteLine("Hello, World!");

Uma linha. É ela a responsável por toda a mágica que você viu. E, apesar de curta, ela está repleta de detalhes que valem ser compreendidos um a um. Vamos dissecá-la da esquerda para a direita.

Átomo por átomo: dissecando a linha

Considere a linha inteira: Console.WriteLine("Hello, World!");. Cada parte tem um papel.

A palavra Console refere-se à janela de texto onde o programa roda — o console, ou terminal. No vocabulário do C#, Console é o nome de uma "caixa de ferramentas" pronta, fornecida pela linguagem, que reúne tudo o que diz respeito a interagir com essa janela de texto: escrever nela, ler o que o usuário digita nela, e assim por diante. Quando você escreve Console, está dizendo "quero usar algo da caixa de ferramentas do console".

O ponto (.) que vem depois é um conector fundamental em C#, que você verá o tempo todo. Ele significa, aproximadamente, "de dentro de" ou "acesse, deste, o seguinte". Em Console.WriteLine, o ponto diz: "de dentro da caixa de ferramentas Console, use a ferramenta WriteLine". É como pedir, numa loja, "da seção de ferramentas, o martelo": o ponto separa o onde (Console) do o quê (WriteLine).

A palavra WriteLine é o nome de uma ação — no vocabulário da programação, uma ação como essa se chama método (estudaremos métodos a fundo mais adiante; por ora, entenda-o como uma ferramenta que faz algo). O que WriteLine faz é exatamente o que o nome sugere em inglês: "escreva uma linha". Ela exibe na tela o texto que você lhe fornecer, e depois pula para a linha seguinte.

Os parênteses ( ) logo após WriteLine são como você aciona a ação e, ao mesmo tempo, entrega a ela a informação de que ela precisa. Uma ação como "escrever uma linha" precisa saber o que escrever — e é isso que colocamos entre os parênteses. Essa informação entregue a uma ação chama-se argumento. Aqui, o argumento é o texto a ser exibido.

O texto "Hello, World!", entre aspas duplas, é o conteúdo a ser escrito. As aspas são essenciais: elas dizem ao C# "tudo o que está aqui dentro é texto literal, para ser tratado como uma sequência de caracteres, e não como comando". Um trecho de texto entre aspas assim tem um nome que usaremos muito: uma string (do inglês, uma "cadeia" de caracteres). Se você trocar o conteúdo entre as aspas, trocará a mensagem exibida — e faremos isso já.

Finalmente, o ponto e vírgula (;) ao final marca o fim da instrução. Em C#, cada instrução completa termina com ponto e vírgula, assim como em português cada frase termina com um ponto final. Ele diz ao computador: "esta instrução acabou aqui". Esquecer o ponto e vírgula é um dos erros mais comuns de quem começa, e o compilador reclamará se você o omitir — não por implicância, mas porque, sem ele, a máquina não sabe onde uma instrução termina e a próxima começa.

Fazendo o programa ser seu

Compreender é bom; experimentar fixa. Vamos alterar o programa para exibir uma mensagem sua. No VS Code, com o arquivo Program.cs aberto, apague o texto entre as aspas e escreva outra coisa — por exemplo, seu nome numa saudação. Deixe a linha assim:

Console.WriteLine("Olá! Meu nome é Ana e este é meu primeiro programa.");

(Troque pelo seu nome.) Salve o arquivo (no VS Code, Ctrl+S; uma bolinha na aba do arquivo indica alterações não salvas, e ela some ao salvar). Volte ao terminal, certifique-se de que ainda está na pasta OlaMundo, e digite dotnet run novamente. Sua nova mensagem aparecerá. Acabou de fechar, pela primeira vez, o ciclo que você repetirá milhares de vezes na vida de programador: escrever, salvar, executar, ver o resultado. Esse ciclo é o batimento cardíaco da programação.

Você pode ir além: adicione uma segunda linha de instrução, logo abaixo da primeira, para exibir uma segunda mensagem:

Console.WriteLine("Estou aprendendo C# do zero.");
Console.WriteLine("E este programa faz exatamente o que eu mandei.");

Salve e rode. As duas linhas aparecem, na ordem em que foram escritas — porque, como vimos na Aula #01, o computador executa as instruções em sequência, de cima para baixo, na ordem em que estão escritas. Essa ordem importa: se você inverter as duas linhas, a saída inverte junto. A execução sequencial é uma das primeiras verdades fundamentais da programação, e você acabou de vê-la em ação.

Um programa foi criado, compilado e executado — e, mais importante, dissecado. A linha que imprime um texto na tela deixou de ser uma fórmula copiada e passou a ser um conjunto de peças com nomes e funções: o objeto que representa o console, o método que escreve, os parênteses que delimitam o argumento, as aspas que marcam o texto literal e o ponto e vírgula que encerra a instrução.

Esse hábito de olhar átomo por átomo é o que distingue quem aprende de quem decora. Cada símbolo em C# está ali por uma razão, e quando um deles falta, a mensagem de erro que aparece passa a ser legível em vez de assustadora.

Fontes e leituras recomendadas

• Tutorial: crie um app de console em C# — o passo a passo oficial de criação e execução do primeiro programa, complementar a esta aula.
• O comando dotnet run — a documentação oficial do comando que compila e executa o projeto.
• Console.WriteLine (referência) — a referência da ação que exibe texto na tela, com suas variações.
• Estrutura de um programa C# — uma visão de como um programa C# é organizado, útil para revisitar conforme avançamos.
• Trabalhando com o VS Code — vídeos introdutórios oficiais do editor, para ganhar fluência na ferramenta.

Exercícios

Exercício 1

Crie o projeto OlaMundo seguindo os três comandos da aula e execute-o. Confirme que a mensagem Hello, World! aparece. Descreva, com suas palavras, o que cada um dos três comandos (dotnet new console, cd, dotnet run) fez.

Exercício 2

Abra o Program.cs e altere a mensagem para uma saudação com o seu nome. Salve e execute novamente. Depois, explique por que foi necessário salvar o arquivo antes de rodar dotnet run.

Exercício 3

Dissecando a linha Console.WriteLine("Olá!");, explique com suas palavras o papel de cada parte: Console, o ponto, WriteLine, os parênteses, o texto entre aspas, e o ponto e vírgula.

Exercício 4

Adicione três linhas de Console.WriteLine ao seu programa, cada uma com uma mensagem diferente, e execute. Depois, inverta a ordem de duas delas, execute de novo, e explique por que a saída mudou. Que verdade fundamental sobre a execução isso demonstra?

Exercício 5

Propositalmente, remova o ponto e vírgula do final de uma linha, salve e execute. Leia a mensagem de erro que aparece (você não precisa entendê-la por completo). Depois recoloque o ponto e vírgula e confirme que volta a funcionar. Com base nisso, explique por que o ponto e vírgula é importante.