C# Saída (Console.WriteLine)

Um programa que não mostra nada é como uma calculadora sem visor: pode até fazer a conta, mas ninguém fica sabendo o resultado. Desde a primeira aula você usa o Console.WriteLine para escrever no terminal. Nesta aula você conhece de perto ele e o seu irmão, o Console.Write: como pular linha (ou não), como mostrar números, como juntar textos e números numa frase só, e as armadilhas que fazem um programa mostrar 23 quando você esperava 5.

Os programas desta aula foram rodados na máquina fictícia da Ana com o .NET 10 SDK (C# 14), na pasta ~/cs/saida, com dotnet run arquivo.cs. A máquina está em português do Brasil, e isso aparece nos números. As saídas foram copiadas da tela.

A ideia: o letreiro e a máquina de escrever

Pense numa máquina de escrever antiga. Você digita as letras, e o papel anda para a esquerda. Quando a linha acaba, você puxa a alavanca, e o papel desce uma linha e volta para o começo.

O terminal funciona assim. O Console (a "máquina") tem duas teclas principais:

1. Console.WriteLine

Cada WriteLine escreve o que estiver entre os parênteses e termina a linha. Sem nada entre os parênteses, ele só termina a linha: o resultado é uma linha em branco.

Console.WriteLine("Lojinha da Ana");
Console.WriteLine();
Console.WriteLine("Aberta de segunda a sábado.");

$ dotnet run writeline.cs
Lojinha da Ana

Aberta de segunda a sábado.

Console

A classe do .NET que representa o terminal (o "console"). Tudo o que se faz com o terminal começa com Console..

.WriteLine

O método "escrever linha": escreve e pula para a linha de baixo. Escrito exatamente assim, com W e L maiúsculos (aula Sintaxe).

("Lojinha da Ana")

O que vai ser escrito. Entre aspas, é um texto (uma string, aula Strings) e sai exatamente como está, acentos e espaços incluídos.

Console.WriteLine();

Sem nada entre os parênteses: escreve só a quebra de linha. Os parênteses continuam obrigatórios.

2. Console.Write: escrever sem pular linha

O Write escreve e deixa o "cursor" parado logo depois do texto. O próximo Write ou WriteLine continua na mesma linha:

Console.Write("Arroz");
Console.Write(", feijão");
Console.Write(", café");
Console.WriteLine(".");
Console.WriteLine("Fim da lista.");

$ dotnet run write.cs
Arroz, feijão, café.
Fim da lista.

1. Write("Arroz") escreve Arroz e fica ali.
2. Write(", feijão") continua: Arroz, feijão. O espaço depois da vírgula está dentro das aspas; o Write não põe espaço nenhum por conta própria.
3. Write(", café"): Arroz, feijão, café.
4. WriteLine(".") escreve o ponto e, agora sim, termina a linha.
5. WriteLine("Fim da lista.") começa na linha de baixo.

A regra: o WriteLine pula a linha depois do texto, nunca antes. Quem escolhe onde a linha acaba é sempre o último a escrever nela.

O último Write do programa

Se o programa termina com um Write, a linha fica sem fim, e o terminal escreve o prompt dele grudado no seu texto:

Console.Write("Tchau!");

$ dotnet run semfim.cs
Tchau!ana@notebook:~/cs/saida$          « o prompt colou no Tchau!

Não é um erro do programa, mas fica feio. Por isso a última escrita de um programa é quase sempre um WriteLine.

Console.WriteLine("Compras: ");
Console.WriteLine("arroz");
Console.WriteLine("feijão");
Console.WriteLine("café");

Console.Write("Compras: ");
Console.Write("arroz, ");
Console.Write("feijão, ");
Console.WriteLine("café.");

3. Números, contas e outros valores

O WriteLine não escreve só textos. Ele aceita números, contas e outros valores, e transforma cada um em texto para mostrar:

Console.WriteLine(29);
Console.WriteLine(3.5);
Console.WriteLine(10 + 5);
Console.WriteLine(10 / 4);
Console.WriteLine(10.0 / 4);
Console.WriteLine(true);
Console.WriteLine('A');
Console.WriteLine(12.50m);

$ dotnet run numeros.cs
29
3,5
15
2
2,5
True
A
12,50

Você não precisa entender todos os tipos agora; eles têm aulas próprias, a partir de Tipos de Dados. O importante é: com aspas, o C# mostra o texto como está; sem aspas, ele calcula o valor e mostra o resultado.

4. Juntar texto e número com +

Para escrever uma frase com um número no meio, junte as partes com +. Entre dois textos (ou entre um texto e um número), o + não soma: ele emenda. Isso se chama concatenação:

Console.WriteLine("Idade: " + 29);
Console.WriteLine("2" + "3");
Console.WriteLine(2 + 3);
Console.WriteLine("Total: " + 2 + 3);
Console.WriteLine("Total: " + (2 + 3));
Console.WriteLine(2 + 3 + " itens");

$ dotnet run juntar.cs
Idade: 29
23
5
Total: 23                « opa!
Total: 5
5 itens

"Idade: " + 29

Texto + número: o número vira texto e é emendado. O espaço depois dos dois-pontos está dentro das aspas.

"2" + "3"

Dois textos: emenda, e dá o texto 23.

2 + 3

Dois números: soma, e dá 5.

"Total: " + 2 + 3

A armadilha. O C# faz as contas da esquerda para a direita: primeiro "Total: " + 2, que dá o texto "Total: 2"; depois "Total: 2" + 3, que emenda mais um 3. Resultado: Total: 23.

"Total: " + (2 + 3)

O conserto: os parênteses mandam fazer a soma antes. 2 + 3 vira 5, e só depois é emendado.

2 + 3 + " itens"

Aqui a conta vem primeiro, da esquerda: 2 + 3 dá 5, e então 5 + " itens" emenda.

Console.WriteLine("Total: " + 2 + 3 + " itens");

Console.WriteLine("Total: " + (2 + 3) + " itens");

Um jeito mais fácil: $"…"

Emendar muitas partes com + cansa e dá margem a erro. O C# tem um jeito mais limpo, a interpolação: um $ antes das aspas, e os valores entre chaves { } no meio do texto. O que está entre chaves é calculado:

Console.WriteLine($"A Ana tem {29} anos e {10 + 5} maçãs.");

$ dotnet run interp.cs
A Ana tem 29 anos e 15 maçãs.

Com variáveis (a próxima parte do guia, a partir de Variáveis), essa forma fica ainda mais útil: $"Olá, {nome}!". Ela é a preferida no C# moderno e tem aula própria: Interpolação. Você ainda vai encontrar, em código antigo, a forma com números entre chaves, Console.WriteLine("{0} tem {1} anos.", "Ana", 29);, que mostra Ana tem 29 anos.; o {0} é trocado pelo primeiro valor depois do texto, o {1} pelo segundo.

5. Quebras de linha e tabulação dentro do texto

Dentro das aspas, a barra invertida \ começa uma sequência de escape: um código para um caractere que não dá para digitar direto. As três mais usadas:

Console.WriteLine("Arroz\nFeijão");
Console.WriteLine("Item\tPreço");
Console.WriteLine("Ela disse \"oi\".");

$ dotnet run escapes.cs
Arroz
Feijão
Item	Preço
Ela disse "oi".

A lista completa, e os textos de várias linhas com """, estão em Escapes e Strings Literais. Para começar, prefira um WriteLine por linha: é mais fácil de ler que um texto cheio de \n.

6. A saída de erro: Console.Error

Todo programa tem, na verdade, duas saídas: a saída padrão (standard output), para os resultados, e a saída de erro (standard error), para avisos e mensagens de problema. O Console.WriteLine escreve na primeira; o Console.Error.WriteLine, na segunda:

Console.WriteLine("Calculando...");
Console.Error.WriteLine("Atenção: estoque baixo!");
Console.WriteLine("Pronto.");

$ dotnet run erro.cs
Calculando...
Atenção: estoque baixo!
Pronto.
$ dotnet run erro.cs 2>/dev/null
Calculando...
Pronto.                  « a saída de erro foi descartada
$ dotnet run erro.cs >/dev/null
Atenção: estoque baixo!  « só sobrou a saída de erro

Na tela, as duas aparecem misturadas e parecem iguais. A diferença surge quando a saída é redirecionada: o 2>/dev/null do terminal joga fora só a saída de erro, e o >/dev/null joga fora só a padrão. Assim, quem guarda os resultados de um programa num arquivo não recebe os avisos misturados. (Os redirecionamentos são do terminal, não do C#; no editor do guia, as duas saídas aparecem juntas, na ordem.) Por enquanto, use o Console.WriteLine para tudo; o Console.Error volta a aparecer com as Exceções.

Write ou WriteLine: qual usar

Quando dá errado

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

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

$ dotnet run semaspas.cs                « Console.WriteLine(Olá);
/home/ana/cs/saida/semaspas.cs(1,19): error CS0103: O nome "Olá" não existe no contexto atual

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

$ dotnet run dois.cs
/home/ana/cs/saida/dois.cs(1,27): error CS1003: Erro de sintaxe, "," esperado

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

$ dotnet run virgula.cs
Idade:                   « cadê o 29?
Ana tem 29 anos.

Referência rápida

Exercícios

Missão final: o cupom da lojinha

Cupom da Lojinha
================

Caderno: 12,50
Caneta: 3,20
Total: 15,70

Console.WriteLine("Cupom da Lojinha");
Console.WriteLine("================");
// linha em branco

Console.Write("Caderno: ");
Console.WriteLine(12.50m);
// a caneta custa 3.20m

// o total: deixe o C# somar

Console.WriteLine("Cupom da Lojinha");
Console.WriteLine("================");
Console.WriteLine();

Console.Write("Caderno: ");
Console.WriteLine(12.50m);
Console.Write("Caneta: ");
Console.WriteLine(3.20m);

Console.Write("Total: ");
Console.WriteLine(12.50m + 3.20m);

Repare que o preço sai com vírgula (12,50), mas no código é escrito com ponto (12.50m). E o C# acertou a soma do dinheiro sem nenhum erro de arredondamento, porque o tipo decimal foi feito para isso.

Resumo

• Console.WriteLine(…) escreve e pula a linha depois; Console.WriteLine() faz uma linha em branco.
• Console.Write(…) escreve e fica na mesma linha. Ótimo para perguntas e linhas montadas aos pedaços. Termine o programa com um WriteLine.
• Com aspas, o texto sai como está; sem aspas, o C# calcula. No código o decimal é com ponto (3.5); na tela, num computador em pt-BR, sai com vírgula (3,5). true aparece como True.
• + entre texto e número emenda, da esquerda para a direita: "Total: " + 2 + 3 dá Total: 23. Use parênteses ou, melhor, $"Total: {2 + 3}".
• Dentro das aspas: \n quebra a linha, \t tabula, \" é uma aspa.
• Console.Error.WriteLine escreve na saída de erro, separada da saída padrão.
• Erros comuns: Writeln/writeline (CS0117), print e texto sem aspas (CS0103), Write() vazio (CS1501) e a vírgula no lugar do +, que compila e esconde o valor.