C# Olá, Mundo

Chegou a hora de escrever o seu primeiro programa em C#. Ele é pequeno: só mostra a frase Olá, mundo! na tela. Mas, para chegar até ela, você vai fazer o caminho que todo programa faz: escrever o código num arquivo e pedir ao dotnet para compilar e rodar. No C# moderno, o programa inteiro cabe numa linha, e nesta aula você entende cada pedacinho dela, sem pular nenhum símbolo.

Todos os comandos desta aula foram executados na máquina fictícia da Ana (usuária ana, computador notebook), com o .NET SDK 10.0.112 do Ubuntu 26.04, numa pasta chamada ~/cs. As saídas foram copiadas da tela, sem mudar nada. Se você ainda não instalou o .NET, volte para Instalar no Linux (ou Windows e macOS). Se ainda não quer instalar, você pode fazer quase tudo no editor do guia, que compila e roda C# de verdade no navegador (O Editor do Guia).

A ideia: a receita e o bolo

Pense numa receita de bolo escrita num papel. O papel não é o bolo: alguém precisa ler a receita e fazer o bolo. Em C# é igual:

O comando dotnet run faz as duas etapas de uma vez: primeiro compila (se houver um erro, para aí e mostra a mensagem), depois roda. A aula .NET: SDK, Runtime e CLR mostra o que acontece por dentro, e a próxima aula, Rodar com dotnet run, mostra tudo o que esse comando sabe fazer. Aqui você só precisa de dois passos: escrever e rodar.

1. Criar a pasta e o arquivo

Comece criando uma pasta só para os seus programas, para eles não se misturarem com fotos e documentos. No terminal:

$ mkdir cs               « cria a pasta "cs" dentro da sua pasta pessoal
$ cd cs                  « entra nela

Os dois comandos não mostram nada quando dão certo: o terminal só volta a mostrar o prompt, agora com ~/cs no fim. (mkdir e cd são comandos do terminal, não do C#. Eles são explicados no Guia Bash.)

Agora crie o arquivo. Qualquer editor de texto serve (o VS Code, o editor de textos do sistema… veja Editores e IDEs). Aqui vamos usar o nano, que roda dentro do próprio terminal e já vem no Ubuntu:

$ nano ola.cs            « abre o nano com um arquivo novo chamado ola.cs

O terminal vira um editor. No alto aparece GNU nano 8.7.1 e o nome ola.cs; embaixo, [ Novo arquivo ] e uma lista de atalhos, como ^O Gravar e ^X Sair. O ^ quer dizer a tecla Ctrl. Digite o programa, que tem uma linha só:

Console.WriteLine("Olá, mundo!");

1. Digite a linha exatamente como está, com as letras maiúsculas no mesmo lugar (C, W e L).
2. Aperte Ctrl + O (^O Gravar). Embaixo aparece Escrever para o arquivo: ola.cs.
3. Aperte Enter para confirmar o nome. O nano responde [ Escrita 1 linha ].
4. Aperte Ctrl + X (^X Sair) para voltar ao terminal.

Três cuidados ao salvar:

• A extensão é .cs, de C sharp. Ela diz ao dotnet e ao editor que o arquivo é código C#.
• Sem espaços e sem acentos no nome: ola.cs, e não olá mundo.cs. Funciona com espaços, mas você teria de usar aspas em todo comando.
• Digite, não copie e cole, pelo menos desta vez. Digitar faz você reparar em cada símbolo, e em C# os símbolos importam.

Para conferir que o arquivo está na pasta certa e com o conteúdo certo, use ls (lista os arquivos) e cat (mostra o conteúdo):

$ ls
ola.cs
$ cat ola.cs
Console.WriteLine("Olá, mundo!");

2. O programa, palavra por palavra

Uma linha só, mas cada símbolo tem uma função. Leia com calma; não precisa decorar nada agora, porque você vai escrever essa linha tantas vezes que ela vai grudar sozinha.

Console.WriteLine("Olá, mundo!");

Console

O "console" é a tela de texto onde o programa conversa com você: o terminal. Em C#, Console é uma classe pronta, que vem com o .NET e reúne tudo o que se pode fazer com essa tela: escrever, ler o que a pessoa digita, limpar, mudar a cor. Ela começa com C maiúsculo, e isso importa.

.

O ponto quer dizer "de dentro de": Console.WriteLine é "o WriteLine que mora dentro do Console". Você vai ver esse ponto o tempo todo em C#: Math.Sqrt, nome.Length, File.ReadAllText.

WriteLine

"Escrever linha" (write = escrever, line = linha): escreve o texto e, no fim, pula para a linha de baixo. É um método, uma ação que se pode pedir a uma classe. Também com maiúsculas: W e L.

( )

Os parênteses depois do nome chamam o método: "WriteLine, faça o seu trabalho com isto aqui dentro". O que vai entre eles se chama argumento.

"Olá, mundo!"

O texto, entre aspas duplas. As aspas dizem ao compilador "isto é texto para mostrar, não é código", e não aparecem na tela. Um texto entre aspas se chama string (aula Strings). Dentro das aspas vale tudo: acentos, espaços, a vírgula, a exclamação.

;

O ponto e vírgula termina a instrução, como o ponto final de uma frase. Esquecê-lo é o erro número um de quem começa, e você vai vê-lo no fim desta aula.

E onde está o resto do programa?

Se você já viu um programa em C# num livro ou num vídeo, deve estar estranhando: cadê o using System;, o class Program e o static void Main? Desde o C# 9, eles não são mais obrigatórios. Duas regras deixam o programa curto:

• Instruções de nível superior (top-level statements): você escreve as instruções direto no arquivo, e o compilador cria sozinho, por baixo, a "moldura" que o programa precisa. O programa começa na primeira linha e vai até a última.
• using automáticos C# 10: o Console mora num "endereço" chamado System. Antes, era preciso escrever using System; no topo; hoje, o .NET já faz isso por você.

A forma antiga continua funcionando e aparece na seção 6. A aula Program.cs e o Main mostra que as duas formas são o mesmo programa.

3. Rodar o programa

Com o arquivo salvo, peça ao dotnet para compilar e rodar:

$ dotnet run ola.cs
Olá, mundo!

Pronto: esse é o seu primeiro programa em C# funcionando. As aspas não apareceram, e o prompt voltou na linha de baixo, porque o WriteLine pula a linha no fim.

dotnet

O comando do .NET, que você instalou.

run

"Rodar": compila e roda.

ola.cs

O arquivo a rodar.

Duas coisas que você pode estranhar:

• A primeira vez demora uns segundos. O dotnet precisa preparar tudo e compilar. Da segunda vez em diante, se o arquivo não mudou, ele reaproveita o que já compilou e responde quase na hora. Na primeiríssima vez depois de instalar o .NET, aparece também uma mensagem de boas-vindas (aula Instalar no Linux).
• Nenhum arquivo novo apareceu na pasta. O dotnet run guarda o programa compilado numa pasta escondida, longe da sua (a aula Rodar com dotnet run mostra onde). Na sua pasta, continua só o ola.cs.

Agora é a sua vez. O editor abaixo compila e roda C# de verdade no navegador (a primeira vez demora alguns segundos, porque ele baixa o compilador e o .NET). Ele faz o mesmo que o dotnet run quando você clica em Rodar.

Console.WriteLine("Olá, mundo!");

Console.WriteLine("Olá, Ana!");

4. Mostrar mais de uma linha

Um programa pode ter quantas instruções você quiser. Elas rodam uma depois da outra, de cima para baixo, cada uma terminada com ;:

Console.WriteLine("Olá! Eu sou a Ana.");
Console.WriteLine("Estou aprendendo C#.");
Console.WriteLine("Este é o meu primeiro programa.");

$ dotnet run tres.cs
Olá! Eu sou a Ana.
Estou aprendendo C#.
Este é o meu primeiro programa.

Cada WriteLine escreve uma linha e pula para a próxima. A ordem na tela é a ordem no arquivo: o computador não pula nem troca nenhuma instrução de lugar. (Mais tarde, com if e while, você vai aprender a decidir e a repetir.)

Console.WriteLine("Olá! Eu sou a Ana.");
Console.WriteLine("Estou aprendendo C#.");
Console.WriteLine("Este é o meu primeiro programa.");

Console.WriteLine("Olá! Eu sou a Ana.");
Console.WriteLine("Estou aprendendo C#.");
Console.WriteLine("Este é o meu primeiro programa.");
Console.WriteLine("Até a próxima!");

Write e WriteLine

O Console tem um irmão do WriteLine: o Write, que escreve sem pular a linha. E um WriteLine() com os parênteses vazios só pula uma linha:

Console.Write("Olá, ");
Console.Write("mundo!");
Console.WriteLine();
System.Console.WriteLine("Com o nome completo: System.Console");

$ dotnet run write.cs
Olá, mundo!                                     « os dois Write ficaram na mesma linha
Com o nome completo: System.Console

A última linha mostra outra coisa: System.Console é o nome completo do Console, com o "endereço" System na frente. Funciona igual, só é mais comprido; por isso ninguém escreve assim. A aula Saída (Console.WriteLine) mostra tudo o que o Write e o WriteLine sabem fazer, e a aula Namespaces e using explica o System.

5. Maiúsculas e minúsculas

O C# diferencia letras maiúsculas de minúsculas: Console, console e CONSOLE são três nomes diferentes, e só o primeiro existe. O mesmo vale para WriteLine: Writeline, com o l minúsculo, não existe. É o tipo de erro que mais confunde no começo, porque, para nós, "é a mesma palavra". Os dois erros estão em Quando dá errado, com as mensagens reais.

O costume do C# é escrever os nomes de classes e métodos com a primeira letra de cada palavra em maiúscula: Console, WriteLine, ReadLine. Isso se chama PascalCase (aula Nomes e Convenções). Sabendo a regra, fica fácil adivinhar como se escreve.

6. O código de saída

Todo programa, quando termina, entrega um número ao sistema: o código de saída. 0 quer dizer "terminei sem problemas"; qualquer outro número quer dizer "algo deu errado". No terminal, o código de saída do último programa fica guardado em $?, e o echo o mostra:

$ dotnet run ola.cs
Olá, mundo!
$ echo $?
0                        « 0: deu tudo certo

O programa termina sozinho com 0 quando chega ao fim do arquivo. Para escolher outro número, termine com return e o número:

Console.WriteLine("Até logo!");
return 7;

$ dotnet run ate.cs
Até logo!
$ echo $?
7                        « o 7 do return chegou ao terminal

Para que serve isso? Scripts e outros programas usam o código de saída para saber se o seu programa deu certo. O próprio dotnet run faz isso: quando a compilação falha, ele sai com o código 1 (você vai ver em "Quando dá errado"). O editor do guia mostra o código de saída embaixo da saída do programa. A aula Program.cs e o Main conta mais sobre o return.

Console.WriteLine("Olá, mundo!");

Console.WriteLine("Até logo!");
return 7;

7. A forma antiga: class Program e static void Main

Até o C# 8, todo programa precisava de uma moldura de nove linhas. Você vai encontrá-la em muitos livros, cursos e respostas na internet, e no projeto que o Visual Studio cria se você marcar a opção "não usar instruções de nível superior". Este é o mesmo Olá, mundo, na forma antiga:

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Olá, mundo!");
    }
}

$ dotnet run antigo.cs
Olá, mundo!                                     « o mesmo resultado

A linha que faz alguma coisa é a mesma de antes, o Console.WriteLine. O resto é a moldura: using System; traz o endereço do Console; class Program cria uma classe chamada Program; static void Main() é o método principal, por onde o programa começa; as chaves { } marcam onde cada parte começa e termina. Hoje, o compilador escreve essa moldura por você, escondida. Cada pedaço tem aula própria: Program.cs e o Main, Classes e Objetos, static e Métodos.

Formas de escrever o Olá, mundo

Qual usar? A primeira. Ela é a mais clara, e é a que o próprio .NET usa nos modelos novos. Quando encontrar a forma antiga, lembre: o miolo é o mesmo.

Quando dá errado

Errar faz parte. Um erro de compilação não estraga nada: o compilador só se recusa a rodar o programa até você consertar. Repare que todas as mensagens têm o mesmo formato: o arquivo, a (linha,coluna), a palavra error, um código CSxxxx e a explicação. O código é igual em qualquer língua: procurando "CS1002" na internet, você acha a explicação.

Console.WriteLine("Olá, mundo!")

$ dotnet run semponto.cs
/home/ana/cs/semponto.cs(1,33): error CS1002: ; esperado

Ocorreu uma falha no build. Corrija os erros de build e execute novamente.
$ echo $?
1                        « o dotnet avisa que falhou: código 1

console.WriteLine("Olá, mundo!");

$ dotnet run minuscula.cs
/home/ana/cs/minuscula.cs(1,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.

Console.Writeline("Olá, mundo!");

$ dotnet run writeline.cs
/home/ana/cs/writeline.cs(1,9): error CS0117: "Console" não contém uma definição para "Writeline"

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

Console.WriteLine("Olá, mundo!);

$ dotnet run aspas.cs
/home/ana/cs/aspas.cs(1,19): error CS1010: Newline em constante
/home/ana/cs/aspas.cs(1,33): error CS1026: ) esperado
/home/ana/cs/aspas.cs(1,33): error CS1002: ; esperado

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

$ dotnet run ola.cs
Não foi possível localizar um projeto para executar. Verifique se existe um projeto em /home/ana/vazio ou passe o caminho para o projeto usando --project.

Referência rápida

Exercícios

Missão final: o cartão de visita

Ana Souza
Programadora C#
Recife - PE

// escreva o programa aqui (esta linha é um comentário: o compilador ignora)

Console.WriteLine("Ana Souza");
Console.WriteLine("Programadora C#");
Console.WriteLine("Recife - PE");

Resumo

• Um programa em C# pode ter uma linha só: Console.WriteLine("Olá, mundo!");. O arquivo termina em .cs.
• Console é a tela de texto; o ponto quer dizer "de dentro de"; WriteLine escreve e pula a linha; o texto vai entre aspas; o ; termina a instrução.
• dotnet run ola.cs compila e roda. A primeira vez demora uns segundos; depois, é quase na hora.
• As instruções rodam de cima para baixo. Write escreve sem pular a linha.
• O C# diferencia maiúsculas: console dá CS0103, Writeline dá CS0117. Sem ;, CS1002; sem fechar aspas, CS1010.
• echo $? mostra o código de saída: 0 se deu certo, 1 se a compilação falhou, ou o número do return.
• A forma antiga, com class Program e static void Main, é o mesmo programa com a moldura à mostra.
• Próximo passo: Rodar com dotnet run, tudo o que esse comando sabe fazer.