C# Lendo Erros do Compilador

Todo programador, do primeiro dia ao vigésimo ano, vê erros de compilação o tempo todo. A diferença é que quem tem experiência lê a mensagem e sabe onde olhar em segundos. As mensagens do compilador C# seguem sempre o mesmo formato, uma linha por erro, e cada uma traz um código, como CS0029, que é igual no mundo inteiro. Nesta aula você aprende a ler esse formato parte por parte, conhece os erros mais comuns de quem começa, com a mensagem real e o conserto, e descobre como achar ajuda em inglês para qualquer erro.

Você vai aprender

As partes de uma mensagem: arquivo(linha,coluna): error CS0029: descrição.
A diferença entre error e warning, e o que acontece com o programa em cada caso.
Por que o código CS importa mais que a frase, e como ver a mensagem em inglês para pesquisar.
Um método para consertar sem se perder: o primeiro erro primeiro.
Os erros mais comuns de quem começa: ;, nome, tipo, aspas, chaves, método, using e quantidade de argumentos.
Por que um engano às vezes vira várias mensagens, e por que um conserto às vezes revela erros novos.
Como os erros aparecem num projeto (dotnet build) e a diferença entre erro de compilação e exceção.

Todos os códigos desta aula têm erros de propósito. Eles foram rodados na máquina fictícia da Ana com o .NET 10 SDK (C# 14), na pasta ~/cs/erros, com dotnet run arquivo.cs. As mensagens saem em português, como num Ubuntu em pt-BR, e foram copiadas da tela sem mudar nada, inclusive os pequenos tropeços da tradução.

A ideia: a redação corrigida

Quando a professora corrige uma redação, ela não reescreve o texto. Ela faz um círculo vermelho no lugar do problema e escreve na margem: "linha 4: falta pontuação", "linha 7: concordância". Às vezes usa um código: "C" para concordância, "P" para pontuação.

O compilador faz o mesmo com o seu código. Ele lê o arquivo inteiro e, para cada problema, anota onde (arquivo, linha e coluna), um código (CS1002) e o que esperava encontrar. Duas coisas para guardar desde já:

Um erro de compilação não estraga nada. O programa só não roda até você consertar. Pode errar à vontade.
O compilador diz onde percebeu o erro, e isso nem sempre é onde você errou. Você vai ver por quê.

1. Anatomia de uma mensagem

A Ana esqueceu o ponto e vírgula no fim da linha 1:

Console.WriteLine("Lista de compras")
Console.WriteLine("Arroz");

$ dotnet run pv.cs; echo "código de saída: $?"
/home/ana/cs/erros/pv.cs(1,38): error CS1002: ; esperado

Ocorreu uma falha no build. Corrija os erros de build e execute novamente.
código de saída: 1

A primeira linha é a mensagem do compilador. Ela tem cinco partes:

/home/ana/cs/erros/pv.cs: O arquivo, com o caminho completo. Num programa com vários arquivos, é aqui que você descobre qual abrir. (No editor do guia, o arquivo da caixa se chama Program.cs.)
(1,38): A posição: linha 1, coluna 38. A coluna é o número do caractere na linha, contando da esquerda a partir de 1. A linha 1 tem 37 caracteres; a coluna 38 é logo depois do ), exatamente onde o ; deveria estar.
error: O tipo da mensagem: um erro de verdade. O programa não é gerado (veja a seção 2).
CS1002: O código do erro. CS vem de C Sharp, e o número identifica o tipo de problema. É a parte mais útil para pesquisar (seção 3).
; esperado: A descrição: o compilador esperava um ; naquela posição e não achou.

E as outras linhas:

Linha	O que é
(linha vazia)	Só um separador.
`Ocorreu uma falha no build. Corrija os erros de build e execute novamente.`	Não é do compilador: é o `dotnet run` avisando que, como a compilação (o build) falhou, ele não rodou o programa. Repare que nem o `Arroz`, da linha 2, que estava certa, apareceu.
`código de saída: 1`	Do `echo $?` (aula Program.cs e o Main): o `dotnet` terminou com 1, que quer dizer "deu errado".

Para quem vem do gcc ou do Java

O compilador C# não copia a linha do seu código na mensagem, nem desenha um ^ embaixo do lugar do erro. Ele dá só o (linha,coluna). Os editores fazem o resto: no VS Code, o lugar fica sublinhado em vermelho, e Ctrl+G pula para uma linha (aula Editores e IDEs).

Missão: este programa está certo. Apague o ; do fim da linha 1, rode e leia a mensagem: o arquivo, a linha, a coluna, o error, o código e a descrição. Depois, conte os caracteres da linha 1 e confira a coluna.

Console.WriteLine("Lista de compras");
Console.WriteLine("Arroz");

Console.WriteLine("Lista de compras")
Console.WriteLine("Arroz");

2. `error` e `warning`

As mensagens do compilador são de dois tipos. Aqui a Ana escreveu o nome da variável errado (idadi em vez de idade; variáveis são da aula Variáveis):

int idade = 29;
Console.WriteLine(idadi);

$ dotnet run nome.cs
/home/ana/cs/erros/nome.cs(2,19): error CS0103: O nome "idadi" não existe no contexto atual
/home/ana/cs/erros/nome.cs(1,5): warning CS0219: A variável "idade" é atribuída, mas seu valor nunca é usado

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

Tipo	Quer dizer	O programa roda?
`error`	Erro: o código está fora das regras do C#.	Não
`warning`	Aviso: o código segue as regras, mas tem cara de engano. Aula Avisos do Compilador.	Sim, se não houver nenhum `error`

Aqui o aviso é consequência do erro: como a única linha que usava a idade tinha o nome errado, o compilador acha que a idade nunca foi usada. Consertando o idadi, o aviso some junto. O compilador do C# não sugere o nome certo ("você quis dizer…?"); quem faz isso é o editor, enquanto você digita.

3. O código `CS` e a língua da mensagem

As mensagens saem em português porque o computador da Ana está em português. A frase muda de língua, mas o código não: CS0029 é o mesmo erro no Brasil, no Japão e nos Estados Unidos. Isso é ótimo para pesquisar, porque quase toda a ajuda da internet está em inglês.

int idade = "vinte e nove";
Console.WriteLine(idade);

$ dotnet run tipo.cs
/home/ana/cs/erros/tipo.cs(1,13): error CS0029: Não é possível converter implicitamente tipo "string" em "int"

Ocorreu uma falha no build. Corrija os erros de build e execute novamente.
$ LANG=C dotnet run tipo.cs
/home/ana/cs/erros/tipo.cs(1,13): error CS0029: Cannot implicitly convert type 'string' to 'int'

The build failed. Fix the build errors and run again.

O LANG=C na frente do comando pede as mensagens sem tradução, só para aquele comando. (Na verdade, a Ana acrescentou um comentário vazio, //, no fim do arquivo antes do segundo comando. Sem mudar o arquivo, o dotnet run não recompila e mostra o resultado guardado da vez anterior.)

Para pesquisar, use o código: CS0029, ou C# CS0029. A documentação oficial da Microsoft (em learn.microsoft.com) tem uma página para cada código, em inglês (muitas com tradução para o português), quase sempre com exemplos do erro e do conserto. Pesquisar a frase traduzida dá muito menos resultados.

De repente, as mensagens em inglês (ou em português)

Para ganhar tempo, o dotnet deixa o compilador ligado em segundo plano depois do primeiro uso (o "servidor de build"). Ele guarda a língua de quando foi ligado. Se o primeiro comando do dia foi com LANG=C, os seguintes continuam em inglês, mesmo sem o LANG=C. Para voltar ao normal, desligue o servidor:

$ dotnet run lista.cs
/home/ana/cs/erros/lista.cs(1,39): error CS1002: ; expected      « em inglês, sem LANG=C!

Ocorreu uma falha no build. Corrija os erros de build e execute novamente.
$ dotnet build-server shutdown
Desligando Servidor MSBuild...
Desligando Servidor do compilador VB/C#...
Servidor MSBuild desligado com sucesso.
Servidor do compilador VB/C# desligado com sucesso.
$ dotnet run lista.cs
/home/ana/cs/erros/lista.cs(1,39): error CS1002: ; esperado

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

Repare que a última linha estava em português o tempo todo: ela é do dotnet, e não do compilador.

4. O vocabulário das mensagens

Algumas palavras aparecem em quase toda mensagem. Com elas, você entende a maioria dos erros, nas duas línguas:

Na mensagem em português	Em inglês	Quer dizer
`esperado` / `esperada`	`expected`	Faltou isso aqui (`; esperado`)
`não existe no contexto atual`	`does not exist in the current context`	Nome desconhecido: escrito errado, ou criado em outro lugar
`não contém uma definição para`	`does not contain a definition for`	O nome antes do ponto existe, o depois não
`Não é possível converter implicitamente`	`Cannot implicitly convert`	Tipo errado: um valor de um tipo onde se esperava outro
`sobrecarga`	`overload`	Uma das versões de um método (aula Sobrecarga)
`argumento`	`argument`	Um valor entre os parênteses de um método
`diretiva using`	`using directive`	Uma linha `using …;` no topo do arquivo
`tipo` / `namespace`	`type` / `namespace`	`int`, `string`, uma classe… / o "sobrenome" de um grupo de classes
`Erro de sintaxe`	`Syntax error`	Erro de escrita: sinais, pares, ordem (aula Sintaxe)
`Newline em constante`	`Newline in constant`	Aspas que não fecharam na linha
`final do arquivo`	`end-of-file`	O arquivo acabou antes da hora (ou depois)
`Ocorreu uma falha no build.`	`The build failed.`	O resumo do `dotnet`: houve pelo menos um `error`

5. O método: um erro de cada vez

Leia só o primeiro error. Os seguintes podem ser consequência dele.
Vá até o arquivo, a linha e a coluna indicados.
Leia a descrição com o vocabulário acima. Se não entender, pesquise o código.
Se a linha parece certa, olhe a de cima. Aspas e chaves esquecidas são percebidas só depois.
Corrija só esse erro e rode de novo. Muitas vezes os outros somem junto, e às vezes aparecem novos (seção 7).

6. Os erros mais comuns de quem começa

6.1. `CS1002: ; esperado`

O da seção 1. A posição aponta onde o ; deveria estar: o fim da instrução. Em inglês, ; expected.

6.2. `CS0103: O nome "…" não existe no contexto atual`

O da seção 2. Um nome que o compilador não conhece: escrito diferente (idadi, console com c minúsculo), usado antes de ser criado, ou um texto sem aspas (Console.WriteLine(Olá);, aula Saída). Em inglês, The name 'idadi' does not exist in the current context. Conserto: copie o nome da mensagem e compare letra por letra, maiúsculas incluídas.

6.3. `CS0029: Não é possível converter implicitamente tipo "string" em "int"`

O da seção 3. A variável idade é do tipo int (número inteiro), e a Ana tentou guardar nela um texto. A coluna 13 aponta o começo do "vinte e nove". "Converter implicitamente" é transformar um valor em outro tipo sozinho, sem você pedir; de texto para número, o C# não faz isso. Conserto: o valor do tipo certo, int idade = 29;. Para transformar um texto digitado em número de propósito, existe o int.Parse (aula Texto → Número).

Missão: rode e leia o erro CS0029. A caixa idade é de número, mas recebeu um texto. Conserte a linha 1 para o programa mostrar A Ana tem 29 anos..

int idade = "29";
Console.WriteLine($"A Ana tem {idade} anos.");

int idade = 29;
Console.WriteLine($"A Ana tem {idade} anos.");

6.4. `CS1010: Newline em constante`

Aspas que não fecharam antes do fim da linha. Costuma vir com uma fila de outros erros: com Console.WriteLine("Lista de numa linha e compras"); na outra, foram seis mensagens (aula Sintaxe):

$ dotnet run quebra.cs 2>&1 | grep -c "error CS"
6

(O 2>&1 | grep -c "error CS" conta as linhas que têm error CS.) Seis erros, um engano só: o primeiro, CS1010. Conserto: feche as aspas na mesma linha.

6.5. Chaves: `CS1513: } esperada` e `CS1022`

Uma { sem a } dá CS1513: } esperada, apontando o fim do arquivo (aula Sintaxe). E uma } sobrando:

Console.WriteLine("Olá!");
}

$ dotnet run sobra.cs
/home/ana/cs/erros/sobra.cs(2,1): error CS1022: Definição de namespace ou tipo, ou final do arquivo esperado

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

"Esperava uma definição de namespace ou de tipo, ou o fim do arquivo": fora de qualquer bloco, uma } não fecha nada, e o compilador esperava outra coisa ali. Em inglês, Type or namespace definition, or end-of-file expected. Conserto: toda { tem a sua }, nem mais nem menos. O recuo bem-feito, ou um dotnet format, mostra quem ficou sem par.

6.6. Nome errado depois do ponto: `CS0117` e `CS1061`

Quando o nome antes do ponto existe, mas o depois não, a mensagem muda. Com uma classe, como o Console, é o CS0117 ("Console" não contém uma definição para "Writeline"; aula Saída). Com um valor, como um texto guardado numa variável, é o CS1061:

string nome = "Ana";
Console.WriteLine(nome.Tamanho);

$ dotnet run metodo.cs
/home/ana/cs/erros/metodo.cs(2,24): error CS1061: ‘string’ não contém uma definição para "Tamanho" e não foi possível encontrar nenhum método de extensão "Tamanho" que aceite um primeiro argumento do tipo ‘string’ (você está se esquecendo de usar uma diretiva ou uma referência de assembly?)

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

A mensagem é longa, mas o começo diz tudo: "string não contém uma definição para Tamanho". O resto fala de "métodos de extensão" (aula Métodos de Extensão) e pode ser ignorado por enquanto. O tamanho de um texto em C# se chama Length (aula Strings): os nomes do .NET são em inglês. Em inglês: 'string' does not contain a definition for 'Tamanho' and no accessible extension method 'Tamanho' accepting a first argument of type 'string' could be found.

6.7. `CS0246: O nome do tipo ou do namespace "…" não pode ser encontrado`

StringBuilder texto = new StringBuilder();
texto.Append("Olá");
Console.WriteLine(texto);

$ dotnet run tiponome.cs
/home/ana/cs/erros/tiponome.cs(1,1): error CS0246: O nome do tipo ou do namespace "StringBuilder" não pode ser encontrado (está faltando uma diretiva using ou uma referência de assembly?)
/home/ana/cs/erros/tiponome.cs(1,27): error CS0246: O nome do tipo ou do namespace "StringBuilder" não pode ser encontrado (está faltando uma diretiva using ou uma referência de assembly?)

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

O StringBuilder existe no .NET, mas mora no namespace System.Text, que não está entre os using implícitos. A própria mensagem sugere a causa: "está faltando uma diretiva using?". O erro aparece duas vezes porque o nome aparece duas vezes na linha 1 (colunas 1 e 27). Em inglês: The type or namespace name 'StringBuilder' could not be found (are you missing a using directive or an assembly reference?). Conserto: using System.Text; no topo do arquivo (aulas Namespaces e using e StringBuilder). O mesmo erro aparece com um tipo escrito errado, como Strng nome.

6.8. `CS1501: Nenhuma sobrecarga para o método "…" leva N argumentos`

O método existe, mas não com aquela quantidade de valores entre os parênteses. O Math.Max ("o maior") compara dois números; com um só:

$ dotnet run args.cs                    « Console.WriteLine(Math.Max(3));
/home/ana/cs/erros/args.cs(2,24): error CS1501: Nenhuma sobrecarga para o método "Max" leva 1 argumentos

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

(O "1 argumentos", no plural, é tropeço da tradução.) Em inglês: No overload for method 'Max' takes 1 arguments. Conserto: confira quantos valores o método espera; o editor mostra isso quando você abre o parêntese.

7. Um engano, várias mensagens, e erros que aparecem depois

O compilador trabalha em etapas. Primeiro ele confere a escrita: sinais, pares, ;. Depois confere o significado: se os nomes existem, se os tipos combinam. No terminal, se a primeira etapa já encontrou erros, o dotnet para ali. Este arquivo tem três problemas:

Console.WriteLine("Lista de compras:")
Console.WriteLine("Arroz");
Console.Writeline("Feijão");
int quantidade = "3";

$ dotnet run lista.cs
/home/ana/cs/erros/lista.cs(1,39): error CS1002: ; esperado

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

Só um erro! A Ana põe o ; na linha 1 e roda de novo:

$ dotnet run lista.cs
/home/ana/cs/erros/lista.cs(3,9): error CS0117: "Console" não contém uma definição para "Writeline"
/home/ana/cs/erros/lista.cs(4,18): error CS0029: Não é possível converter implicitamente tipo "string" em "int"

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

Agora que a escrita está certa, o compilador chegou à segunda etapa e encontrou mais dois. Não é que o conserto "criou" erros: eles estavam lá, escondidos. É por isso que o método diz rode de novo depois de cada conserto. (O editor do guia trabalha nas mesmas etapas: ele também mostra só o CS1002 primeiro, e os outros dois depois do conserto.)

E o contrário também acontece: um engano só pode produzir várias mensagens, como as seis do CS1010 (seção 6.4). Nos dois casos, a saída é a mesma: o primeiro erro primeiro.

8. Os erros num projeto: `dotnet build`

Num projeto (aula Projetos), a mensagem tem uma parte a mais no fim: o .csproj entre colchetes, dizendo de qual projeto ela veio. E o dotnet build mostra cada erro duas vezes: uma durante a compilação e outra no resumo do fim:

$ dotnet build; echo "código de saída: $?"
  Determinando os projetos a serem restaurados...
  Todos os projetos estão atualizados para restauração.
/home/ana/projetos/Ola/Program.cs(2,9): error CS0117: "Console" não contém uma definição para "Writeline" [/home/ana/projetos/Ola/Ola.csproj]
/home/ana/projetos/Ola/Program.cs(3,18): error CS0029: Não é possível converter implicitamente tipo "string" em "int" [/home/ana/projetos/Ola/Ola.csproj]

FALHA da compilação.

/home/ana/projetos/Ola/Program.cs(2,9): error CS0117: "Console" não contém uma definição para "Writeline" [/home/ana/projetos/Ola/Ola.csproj]
/home/ana/projetos/Ola/Program.cs(3,18): error CS0029: Não é possível converter implicitamente tipo "string" em "int" [/home/ana/projetos/Ola/Ola.csproj]
    0 Aviso(s)
    2 Erro(s)

Tempo Decorrido 00:00:01.61
código de saída: 1

São 2 erros, e não 4: o resumo repete os mesmos, para você não precisar rolar a tela quando a compilação é longa. A contagem do fim (2 Erro(s)) é a que vale. Em inglês, o resumo é Build FAILED., 0 Warning(s), 2 Error(s).

9. Erro de compilação, aviso e exceção

Nem todo erro é do compilador. Um programa pode compilar perfeitamente e dar errado na hora de rodar. Esse tipo de erro se chama exceção, e tem outra cara:

$ dotnet run excecao.cs; echo "código de saída: $?"     « int[] notas = { 9, 8 }; Console.WriteLine(notas[5]);
Unhandled exception. System.IndexOutOfRangeException: Index was outside the bounds of the array.
   at Program.<Main>$(String[] args) in /home/ana/cs/excecao.cs:line 2
código de saída: 134

	Erro de compilação	Aviso	Exceção
Quando aparece	Antes de rodar	Antes de rodar	Durante a execução
Como começa	`arquivo(linha,coluna): error CS…`	`arquivo(linha,coluna): warning CS…`	`Unhandled exception. System.…Exception`
Língua	A do computador (aqui, português)	A do computador	Sempre inglês, no Linux
O programa roda?	Não	Sim	Rodou até ali e parou
Código de saída	1 (do `dotnet`)	O do programa	134
Aula	Esta	Avisos do Compilador	Exceções

Os erros de compilação são os melhores erros que existem: aparecem na hora, dizem a linha e não deixam um programa errado chegar a ninguém. É por isso que o C# é tão rigoroso com tipos e nomes: muita coisa que em outras linguagens só daria problema na hora de rodar, aqui é pega antes.

Quando dá errado

"A linha que o compilador apontou está certa!"

O que significa: o compilador aponta onde percebeu o problema. Aspas e chaves esquecidas só são percebidas mais adiante, às vezes no fim do arquivo (CS1513).

Como consertar: leia a descrição e olhe as linhas de cima. Procure o par que não fechou.

"Consertei, mas o erro continua igual"

O que significa: o arquivo não foi salvo (o dotnet lê o disco, não a tela do editor), ou você rodou outro arquivo (pv.cs em vez de pv2.cs), ou outra pasta.

Como consertar: salve (Ctrl+S) e confira o caminho no começo da mensagem: é o arquivo que o compilador leu.

"Consertei um erro e apareceram outros"

O que significa: normal. Os novos estavam escondidos atrás de um erro de escrita (seção 7).

Como consertar: continue o método: o primeiro da nova lista.

As mensagens mudaram de língua sozinhas

O que significa: o servidor de build ficou com a língua de um comando anterior, como um LANG=C (seção 3).

Como consertar: dotnet build-server shutdown, e rode de novo.

"Não entendi a mensagem nem com o vocabulário"

O que significa: algumas mensagens citam assuntos que você ainda não estudou (métodos de extensão, referências de assembly…).

Como consertar: leia só o começo da frase, que costuma bastar, e pesquise o código (CS1061). Veja também a tabela abaixo e a página Erros Comuns.

Referência rápida

Código	Em português	Em inglês	Causa mais comum
`CS1002`	`; esperado`	`; expected`	Faltou o `;`
`CS1026`	`) esperado`	`) expected`	Faltou fechar o parêntese
`CS1513`	`} esperada`	`} expected`	Faltou fechar a chave
`CS1022`	`Definição de namespace ou tipo, ou final do arquivo esperado`	`Type or namespace definition, or end-of-file expected`	Uma `}` a mais
`CS1010`	`Newline em constante`	`Newline in constant`	Aspas que não fecharam
`CS1056`	`Caractere inesperado`	`Unexpected character`	Aspas curvas copiadas
`CS0103`	`O nome "x" não existe no contexto atual`	`The name 'x' does not exist in the current context`	Nome escrito errado ou usado antes de existir
`CS0117`	`"Console" não contém uma definição para "x"`	`'Console' does not contain a definition for 'x'`	Método escrito errado (`Writeline`)
`CS1061`	`'string' não contém uma definição para "x"…`	`'string' does not contain a definition for 'x'…`	Propriedade ou método que não existe naquele valor
`CS0029`	`Não é possível converter implicitamente tipo "string" em "int"`	`Cannot implicitly convert type 'string' to 'int'`	Valor do tipo errado
`CS0246`	`O nome do tipo ou do namespace "X" não pode ser encontrado`	`The type or namespace name 'X' could not be found`	Falta um `using`, ou o tipo está escrito errado
`CS1501`	`Nenhuma sobrecarga para o método "X" leva N argumentos`	`No overload for method 'X' takes N arguments`	Quantidade errada de valores nos parênteses
`CS0201`	`Somente as expressões de atribuição, chamada… podem ser utilizadas como uma instrução`	`Only assignment, call, increment, decrement, await, and new object expressions can be used as a statement`	Uma conta solta, sem fazer nada com ela
`CS5001`	`Programa não contém um método "Main" estático adequado…`	`Program does not contain a static 'Main' method suitable for an entry point`	Sem ponto de entrada (aula Program.cs e o Main)

Exercícios

1. Qual linha?

Em /home/ana/cs/jogo.cs(12,7): error CS0103: O nome "pontos" não existe no contexto atual, em que linha está o problema?

Linha:

2. E a coluna?

Na mesma mensagem, em que coluna?

Coluna:

3. Em inglês

Complete a variável que, na frente de um comando, mostra as mensagens sem tradução:

dotnet run jogo.cs

4. O compilador mostrou 5 erros. O que fazer primeiro?

Corrigir o último, que é o mais recente. Corrigir o primeiro e rodar de novo: os outros podem ser consequência dele. Apagar o arquivo e começar do zero. Pesquisar os 5 ao mesmo tempo.

5. Para pesquisar um erro na internet, qual é a melhor parte da mensagem?

O caminho do arquivo. A frase em português, inteira. O código, como CS0029, que é igual em qualquer língua. A linha Ocorreu uma falha no build.

6. A saída tem uma linha warning CS0219 e nenhuma error. O programa roda?

Sim: avisos não impedem o programa (mas merecem atenção). Não: qualquer mensagem impede o programa. Só se você rodar com LANG=C. Só no editor do guia.

7. Qual mensagem é de uma exceção, e não do compilador?

error CS1002: ; esperado warning CS0219: A variável "x" é atribuída, mas seu valor nunca é usado Ocorreu uma falha no build. Unhandled exception. System.IndexOutOfRangeException: Index was outside the bounds of the array.

Missão final: o boletim

Missão: a Ana escreveu o boletim com pressa. Há quatro erros: um ;, um tipo, um método e um nome. Use o método: rode, conserte só o primeiro erro, rode de novo, e repita. No fim, o programa deve mostrar as três linhas abaixo, sem nenhum aviso:

Boletim da Ana
Matemática: 9
História: 8

Console.WriteLine("Boletim da Ana")
int matematica = 9;
int historia = "8";
Console.Writeline($"Matemática: {matematica}");
Console.WriteLine($"História: {histora}");

Console.WriteLine("Boletim da Ana");
int matematica = 9;
int historia = 8;
Console.WriteLine($"Matemática: {matematica}");
Console.WriteLine($"História: {historia}");

Resumo

Uma mensagem tem arquivo(linha,coluna): tipo código: descrição, como /home/ana/cs/erros/tipo.cs(1,13): error CS0029: …. Num projeto, termina com […/Nome.csproj].
error impede o programa de rodar (Ocorreu uma falha no build., código de saída 1); warning não impede.
O código CS é igual em qualquer língua: pesquise por ele. LANG=C mostra a mensagem em inglês; se as mensagens mudarem de língua sozinhas, dotnet build-server shutdown.
O método: o primeiro erro, a linha e a coluna, a descrição, a linha de cima se preciso, conserte só ele e rode de novo.
Um engano pode virar várias mensagens (CS1010), e um conserto pode revelar erros escondidos: o compilador confere a escrita antes do significado.
Os mais comuns: CS1002, CS0103, CS0029, CS1010, CS1513/CS1022, CS0117/CS1061, CS0246 e CS1501.
Exceções são outra coisa: acontecem ao rodar, saem em inglês e terminam com o código 134.
Próximo passo: Avisos do Compilador, os problemas que não impedem o programa, mas que você deve levar a sério.