C# Glossário

Os termos que aparecem no guia, em ordem alfabética, explicados em uma ou duas frases, cada um com o link para a aula em que é explicado com calma. Termos em inglês aparecem com a tradução. Quando o nome em inglês é o mais usado no dia a dia (como array ou async), ele é a entrada principal.

A · B · C · D · E · F · G · H · I · J · L · M · N · O · P · Q · R · S · T · U · V · W · Y

A

abstract (classe abstrata)

Uma classe que serve só de base e não pode ser criada com new. Pode ter métodos abstract, sem corpo, que toda classe filha é obrigada a implementar com override. Veja: Classes Abstratas.

Acessador (get, set, init)

As partes de uma propriedade: o get roda quando alguém lê o valor; o set, quando alguém atribui; o init, só na criação do objeto. Cada um pode ter o seu modificador de acesso, como em { get; private set; }. Veja: Propriedades e readonly e init.

args

O array de string com o que foi escrito depois do nome do programa na linha de comando: em dotnet run conta.cs -- 10 20, args é ["10", "20"]. Veja: Argumentos da Linha de Comando.

Argumento

O valor que você entrega a um método quando o chama: em Somar(2, 3), os argumentos são 2 e 3. Do lado de dentro, eles chegam nos parâmetros. Veja: Parâmetros e Parâmetros Opcionais e Nomeados.

Array (vetor)

Uma fileira de valores do mesmo tipo, com tamanho fixo: int[] notas = [7, 8, 6];. O primeiro elemento é o de índice 0, e o C# confere todo acesso: passar do fim lança IndexOutOfRangeException. Veja: Arrays, Arrays Multidimensionais e A Classe Array.

async e await

Palavras para esperar uma operação demorada (ler um arquivo, baixar algo) sem travar o programa. Um método async devolve uma Task, e o await pausa o método até a tarefa terminar, deixando a thread livre. Veja: async e await.

Atribuição

Guardar um valor numa variável que já existe, com =: idade = 31;. Não confunda com a comparação ==. Os atalhos +=, -=, *= fazem a conta e guardam. Veja: Variáveis e Operadores de Atribuição.

Atributo

Uma etiqueta entre colchetes que dá uma informação a mais ao compilador ou ao programa: [Obsolete], [Flags], [JsonPropertyName("nome")]. Veja: Atributos.

Aviso (warning)

Mensagem do compilador sobre algo suspeito que não impede o programa de rodar, como CS8602 (possível null) ou CS0168 (variável não usada). Quase sempre aponta um defeito real. Com TreatWarningsAsErrors, todo aviso vira erro. Veja: Avisos do Compilador e Boas Práticas.

B

base

Dentro de uma classe filha, a palavra que se refere à classe-mãe: : base(titular) chama o construtor dela, e base.Metodo() chama a versão dela de um método. Veja: base.

Biblioteca de classes

Um projeto que não roda sozinho: ele gera um .dll com classes para outros programas usarem. Criada com dotnet new classlib e ligada com ProjectReference. Veja: Bibliotecas de Classes.

Bloco

Um trecho de código entre chaves { }, como o corpo de um if, de um laço ou de um método. Uma variável criada dentro de um bloco só existe nele. Veja: Sintaxe e Escopo.

bool

O tipo que guarda só true (verdadeiro) ou false (falso). Toda comparação dá um bool, e toda condição de if e while tem de ser um. Veja: char e bool.

Boxing

Quando um tipo de valor (um int, por exemplo) é guardado numa variável object: o .NET o embrulha numa "caixa" no heap. Tirar da caixa é o unboxing, e um tipo errado lança InvalidCastException. Veja: Valor × Referência.

break e continue

Dentro de um laço, break sai do laço na hora; continue pula o resto da volta atual e começa a próxima. O break também termina cada case de um switch. Veja: break e continue.

Build (compilação)

Transformar o código-fonte no programa: o dotnet build chama o compilador e gera os arquivos em bin/. O dotnet run faz o build antes de rodar, se o código mudou. Veja: Projetos e O Comando dotnet.

C

C# (lê-se "cê sharp")

A linguagem deste guia, criada pela Microsoft em 2000 e hoje de código aberto. É compilada, orientada a objetos e com tipos conferidos pelo compilador. A versão atual é a 14, com o .NET 10. Veja: O que é C# e Versões.

Caminho (path)

O endereço de um arquivo ou pasta: absoluto (/home/ana/cs/notas.txt) ou relativo à pasta atual (notas.txt). Monte caminhos com Path.Combine. Veja: Pastas e Caminhos.

Campo (field)

Uma variável que pertence a um objeto (ou à classe, se for static). Por convenção, campos são private e têm nome _camelCase; o acesso de fora é feito por propriedades. Veja: Campos.

Cancelamento

O jeito combinado de pedir para uma tarefa parar: um CancellationTokenSource dá o sinal, e a tarefa confere o CancellationToken. Veja: Cancelamento.

Cast (conversão explícita)

Forçar a conversão de um tipo em outro escrevendo o tipo entre parênteses: (int)7.9 dá 7 (corta a parte decimal). Pode perder dados, por isso o compilador exige que você peça. Veja: Conversão de Tipos.

catch

O bloco que trata uma exceção lançada dentro do try: catch (FormatException). Pegue só as exceções que você sabe tratar, e nunca deixe um catch vazio. Veja: try e catch.

char

O tipo de um caractere só, entre aspas simples: 'A'. Cada char tem um código numérico ('A' é 65). Veja: char e bool.

Classe

O molde de um tipo de objeto: diz que dados ele guarda (campos e propriedades) e o que ele faz (métodos). class Conta { … }. É um tipo de referência. Veja: O que é POO e Classes e Objetos.

CLR (Common Language Runtime)

A parte do .NET que roda os programas: carrega a IL, compila com o JIT, cuida da memória com o coletor de lixo e das exceções. Veja: .NET: SDK, Runtime e CLR.

Código de saída

O número que o programa devolve ao terminar: 0 é sucesso; outro número, problema. Uma exceção não tratada termina com 134 no Linux. No terminal, echo $? mostra o código. Veja: Rodar com dotnet run e Exceções.

Coleção

Um objeto que guarda vários valores e cresce ou diminui conforme o uso: List, Dictionary, HashSet, Queue, Stack. Veja: Coleções.

Coletor de lixo (garbage collector, GC)

A parte do .NET que libera a memória dos objetos que nenhuma variável alcança mais, numa hora que ele escolhe. Divide os objetos em gerações (0, 1 e 2). Veja: Memória e Coletor de Lixo.

Comentário

Texto para pessoas, que o compilador ignora: // até o fim da linha ou /* em bloco */. O /// faz comentários de documentação. Veja: Comentários.

Compilador

O programa que lê o seu código C# e o transforma em IL. O compilador do C# se chama Roslyn; ele é quem mostra os erros e avisos CS…. Veja: .NET e Lendo Erros do Compilador.

Condição de corrida (race condition)

Quando duas threads mexem na mesma variável ao mesmo tempo e o resultado depende de quem chega primeiro, como num contador++ em paralelo. Resolve-se com lock ou Interlocked. Veja: Sincronização (lock) e Threads.

const (constante)

Um valor com nome que nunca muda e é conhecido na compilação: const decimal Desconto = 0.10m;. Acaba com os "números mágicos" soltos no código. Veja: Constantes.

Construtor

O método especial que roda no new e prepara o objeto: tem o nome da classe e nenhum tipo de retorno. Pode exigir dados (new Conta("Ana")) e conferi-los. Veja: Construtores.

Construtor primário C# 12

Os parâmetros escritos logo depois do nome da classe, class Tela(string nome) { … }, que ficam disponíveis no corpo inteiro. Os records já tinham algo parecido. Veja: Construtores e base.

.csproj

O arquivo XML que descreve um projeto: o tipo de programa (OutputType), a versão do .NET (TargetFramework), os pacotes e as opções, como Nullable. Veja: O Arquivo .csproj.

Cultura

As regras de um país para números, datas e moeda. Na máquina da Ana (pt-BR), 3.5 aparece como 3,5 e o formato C usa R$. CultureInfo.InvariantCulture usa sempre o ponto. Veja: Cultura.

D

DateTime, DateOnly e TimeSpan

Os tipos de data e hora: DateTime guarda data e hora, DateOnly só a data, e TimeSpan uma duração (a diferença entre duas datas). Veja: Datas e Horas.

decimal

O tipo de número com vírgula que guarda em base 10, sem os erros de arredondamento do double: 0.1m + 0.2m dá exatamente 0,3. É o tipo para dinheiro; o sufixo é m. Veja: float, double e decimal.

Delegate

Um tipo que guarda uma referência a um método, para chamá-lo depois ou passá-lo para outro método. Func, Action e Predicate são delegates prontos. Veja: Delegates e Func, Action e Predicate.

Depurador (debugger)

A ferramenta que roda o programa passo a passo, para em pontos de parada e mostra o valor das variáveis. O VS Code e o Rider têm um. Veja: Depuração.

Desconstrução

Tirar os pedaços de uma tupla ou de um record para variáveis separadas, numa linha: var (nome, idade) = pessoa;. Veja: Tuplas e Records.

Dictionary (dicionário)

Uma coleção de pares chave e valor, como uma agenda (nome → telefone): Dictionary<string, int>. Ler uma chave que não existe com [ ] lança KeyNotFoundException; use TryGetValue. Veja: Dictionary.

Diretiva (#:package, #:property) .NET 10

Linhas especiais no topo de um arquivo solto que fazem o papel do .csproj: #:package acrescenta um pacote NuGet e #:property muda uma opção, como TreatWarningsAsErrors=true. Veja: Rodar com dotnet run e O Arquivo .csproj.

Dispose e IDisposable

IDisposable é a interface das classes que seguram algo que precisa ser fechado (um arquivo, uma conexão); Dispose() é o método que fecha. O using chama o Dispose por você. Veja: using e IDisposable.

do while

O laço que roda o corpo antes de testar a condição, por isso roda pelo menos uma vez. Bom para "pergunte até a resposta valer". Veja: do while.

dotnet (o comando)

A ferramenta de linha de comando do .NET: dotnet run, dotnet new, dotnet build, dotnet test, dotnet format, dotnet package add… Veja: O Comando dotnet.

dotnet run arquivo.cs (file-based app) .NET 10

Rodar um arquivo .cs solto, sem criar projeto. É como a Ana roda os programas dos níveis 1 e 2. Veja: Rodar com dotnet run.

double

O tipo padrão de número com vírgula: rápido e com uns 15 dígitos de precisão, mas guarda em base 2, então 0.1 + 0.2 dá 0,30000000000000004. Bom para medidas, ruim para dinheiro. Veja: float, double e decimal.

E

Encapsulamento

Esconder os dados de um objeto e só deixar mexer neles por métodos e propriedades que conferem as regras, como o saldo com private set que só muda por Depositar e Sacar. Veja: Encapsulamento e Conta Bancária.

enum (enumeração)

Um tipo com uma lista fixa de opções com nome: enum DiaDaSemana { Segunda, Terca, … }. Cada opção tem um número por baixo. Veja: Enums.

Erro de compilação

Um problema que impede o programa de ser criado, mostrado como arquivo(linha,coluna): error CS0029: …. O código CS… é o mesmo em qualquer língua. Veja: Lendo Erros do Compilador e Erros do Compilador (CS…).

Escape (sequência de escape)

Uma barra invertida seguida de um caractere, dentro de um texto, que vale por algo difícil de digitar: \n (nova linha), \t (tabulação), \" (aspas). Veja: Escapes e Strings Literais.

Escopo

A região do código em que uma variável existe: o bloco { } em que ela nasceu. Fora dele, o nome dá CS0103. Veja: Escopo.

Evento (event)

Um aviso que um objeto dá para quem se inscreveu: inscreve-se com +=, sai com -= e o dono dispara com ?.Invoke(). Esquecer o -= pode manter objetos vivos na memória. Veja: Eventos e Memória.

Exceção

Um erro durante a execução (não na compilação), como dividir um inteiro por zero ou ler fora de um array. Se ninguém a tratar, o programa cai com Unhandled exception e o código 134. Veja: Exceções, Exceções Próprias e Referência de Exceções.

Execução adiada (deferred execution)

A consulta LINQ não roda quando é escrita, só quando alguém percorre o resultado (foreach, Count(), ToList()). Se a lista mudar antes, o resultado muda. Veja: O que é LINQ e yield return.

Expressão de coleção C# 12

Os colchetes que criam um array ou uma lista: int[] notas = [7, 8, 6];, List<string> vazia = [];. Veja: Arrays e Coleções.

Expressão switch C# 8

A forma do switch que devolve um valor: nota switch { >= 6 => "Aprovado", _ => "Reprovado" }. O _ é o "qualquer outro". Veja: Expressões switch.

Extensão (método de extensão)

Um método static com this no primeiro parâmetro, que pode ser chamado como se fosse do próprio tipo: preco.ComDesconto(). Todo o LINQ é feito assim. O C# 14 trouxe os blocos extension. Veja: Métodos de Extensão.

F

field C# 14

Dentro do get ou do set de uma propriedade, a palavra que dá acesso ao campo de apoio que o compilador cria, sem você declarar um campo à parte. Veja: Propriedades.

File

A classe com os métodos prontos para arquivos: File.ReadAllText, WriteAllText, ReadAllLines, AppendAllText, Exists. Veja: Arquivos (File).

Finalizador

Um método ~NomeDaClasse() que roda quando o coletor de lixo leva o objeto, sem hora marcada. Quase nunca é preciso escrever um; para fechar recursos, use using. Veja: Memória e Coletor de Lixo.

finally

O bloco depois do try (e dos catch) que roda sempre, com ou sem exceção. Bom para limpar e fechar. Veja: finally.

for

O laço com contador: for (int i = 0; i < 5; i++), com início, condição e passo. Veja: for e Laços Aninhados.

foreach

O laço "para cada item da coleção": foreach (string nome in nomes). Não precisa de índice e nunca passa do fim; mudar a lista dentro dele lança InvalidOperationException. Veja: foreach e IEnumerable e foreach.

Formato (C, N2, P…)

Letras que dizem como mostrar um número: {preco:C} (moeda, R$ 12,50), {x:N2} (duas casas e milhar), {taxa:P} (porcentagem). Veja: Formatar Números.

Func, Action e Predicate

Delegates prontos: Func<int, int> recebe e devolve valores, Action<string> só recebe (não devolve nada), Predicate<T> responde true ou false. Veja: Func, Action e Predicate.

Função local

Um método escrito dentro de outro método. Os métodos no fim de um arquivo com instruções de nível superior são funções locais do programa principal. Sem static, elas enxergam as variáveis de fora. Veja: Funções Locais.

G

Generics (genéricos)

Classes e métodos com um "tipo em branco", preenchido na hora de usar: List<T> vira List<int> ou List<Aluno>. Dão reaproveitamento sem perder a conferência de tipos. Veja: Generics e Restrições (where).

Gerações (do coletor de lixo)

As faixas em que o coletor separa os objetos: 0 (recém-criados, varrida muitas vezes), 1 e 2 (os que sobreviveram, varrida raramente). Veja: Memória e Coletor de Lixo.

GroupBy

O método LINQ que separa uma sequência em grupos por uma chave, como produtos por categoria. Cada grupo tem a Key e os seus elementos. Veja: Agrupar (GroupBy).

H

HashSet

Um conjunto: uma coleção que não aceita repetidos (o Add de um item que já existe devolve false) e responde Contains muito rápido. Não garante ordem. Veja: HashSet.

Heap

A área da memória onde ficam os objetos criados com new. Quem libera o heap é o coletor de lixo. Veja: Memória e Coletor de Lixo.

Herança

Uma classe filha recebe tudo de uma classe-mãe e acrescenta o que é dela: class ContaPoupanca : Conta. Em C#, cada classe tem uma mãe só (e todas descendem de object). Veja: Herança.

I

Identificador

O nome que você dá a uma variável, método ou classe. Pode ter letras, dígitos e _, não pode começar com dígito nem ser uma palavra reservada. Veja: Nomes e Convenções.

IEnumerable

A interface de tudo o que pode ser percorrido com foreach: arrays, listas, resultados do LINQ. Um método que recebe IEnumerable<T> aceita qualquer coleção. Veja: IEnumerable e foreach.

if e else

A decisão: o bloco do if roda só se a condição for verdadeira; o do else, caso contrário. else if encadeia várias condições. Veja: if e else e else if.

IL (Intermediate Language, linguagem intermediária)

O código que o compilador do C# gera, guardado no .dll. Não é código de máquina: o JIT o transforma em código do processador na hora de rodar. Veja: .NET.

Imutável

Que não muda depois de criado. A string é imutável (ToUpper devolve um texto novo), e os records posicionais também (use with para uma cópia alterada). Veja: Strings e Records.

Indexador

O que permite usar colchetes num objeto seu, como numa lista: turma[0]. É declarado com this[int indice]. Veja: Indexadores.

Índice

A posição de um elemento num array, lista ou string, começando em 0. ^1 é o último. Veja: Arrays e Índices e Intervalos.

Inferência de tipo

Quando o compilador descobre o tipo sozinho, pelo valor: var total = 0m; é decimal. O tipo continua fixo. Veja: Inferência com var.

Inicializador de objeto

As chaves depois do new que preenchem as propriedades: new Produto { Nome = "Caneta", Preco = 2.5m }. Com required, a propriedade tem de aparecer ali. Veja: Inicializadores e required.

Instruções de nível superior (top-level statements) C# 9

Escrever o programa direto no arquivo, sem class Program e static void Main. O compilador cria o Main por você. Veja: Program.cs e o Main.

int

O tipo padrão de número inteiro, de cerca de −2,1 bilhões a +2,1 bilhões (4 bytes). Passar do limite "dá a volta" (estouro), a menos que use checked. Veja: Inteiros e Tipos e Limites.

Interface

Um contrato: uma lista de métodos e propriedades que uma classe promete ter. O nome começa com I, como IComparable. Uma classe pode implementar várias. Veja: Interfaces.

Interpolação

Um texto com $ na frente em que cada {…} é trocado pelo valor: $"Olá, {nome}!". Aceita formato e largura: {preco,10:C}. Veja: Interpolação.

J

JIT (just-in-time, "na hora certa")

O compilador do CLR que transforma a IL em código do processador enquanto o programa roda, método por método. Veja: .NET.

JSON

Um formato de texto para guardar e trocar dados: { "Nome": "Ana", "Idade": 31 }. No C#, JsonSerializer.Serialize transforma objetos em JSON e Deserialize faz o caminho de volta. Veja: JSON e Agenda de Contatos.

L

Laço (loop, repetição)

Um bloco que repete: while, do while, for e foreach. Um laço cuja condição nunca fica falsa é um laço infinito. Veja: while, for e foreach.

Lambda

Um método sem nome, escrito numa linha: p => p.Preco > 10 ("dado p, devolve se o preço passa de 10"). É o que se passa para o LINQ e para os delegates. Veja: Lambdas.

LINQ (Language Integrated Query)

Os métodos de consulta das coleções: Where (filtrar), Select (transformar), OrderBy (ordenar), GroupBy, Count, Sum… Veja: O que é LINQ e Referência de LINQ.

List (List<T>)

A coleção mais usada: uma lista que cresce com Add, diminui com Remove e é acessada pela posição, como um array sem tamanho fixo. Veja: List<T>.

lock

Um bloco que só uma thread por vez pode executar, para proteger uma variável compartilhada. Veja: Sincronização (lock).

LTS (Long Term Support)

Uma versão do .NET com suporte por três anos, como o .NET 10 (novembro de 2025). As versões STS têm suporte menor. Veja: Versões do C# e do .NET.

M

Main

O método por onde o programa começa (o ponto de entrada): static void Main(string[] args). Com instruções de nível superior, o compilador o cria sozinho. Veja: Program.cs e o Main.

Math

A classe com as funções matemáticas: Math.Max, Math.Pow, Math.Sqrt, Math.Round (que arredonda o ,5 para o par). Veja: Matemática (Math).

Método

Um bloco de código com nome, que recebe parâmetros e pode devolver um valor: decimal CalcularTotal(int quantidade). Veja: Métodos, Valor de Retorno e Sobrecarga.

Modificador de acesso

A palavra que diz quem enxerga um membro ou tipo: public (todos), private (só a própria classe), internal (o mesmo projeto), protected (a classe e as filhas). Veja: public, private e internal.

N

Namespace

Um "sobrenome" que agrupa tipos e evita conflitos de nome: a classe JsonSerializer mora em System.Text.Json. O using no topo do arquivo dispensa escrever o nome completo. Veja: Namespaces e using.

.NET

A plataforma em que o C# roda: o compilador, o runtime (CLR), a biblioteca de classes e as ferramentas. É gratuita, de código aberto e roda em Linux, Windows e macOS. Veja: .NET: SDK, Runtime e CLR.

new

Cria um objeto (ou um array) e chama o construtor: new Conta("Ana"). Quando o tipo já está escrito à esquerda, basta new(). Veja: Classes e Objetos.

NuGet

O repositório de pacotes do .NET (nuget.org). dotnet package add NomeDoPacote acrescenta uma biblioteca ao projeto. Veja: Pacotes NuGet.

null

"Nenhum objeto": o valor de uma referência que não aponta para nada. Usar um membro de algo null lança NullReferenceException. Tipos de valor só aceitam null com ? (int?). Veja: null e Tipos Anuláveis e Operadores ??, ?. e ??=.

O

object

A classe-mãe de todos os tipos do C#. Todo objeto herda dela ToString, Equals, GetHashCode e GetType. Veja: A Classe object.

Objeto (instância)

Uma "ficha preenchida" criada a partir de uma classe com new, com os seus próprios valores. A classe Conta é o molde; a conta da Ana é um objeto. Veja: Classes e Objetos.

Operador

Um símbolo que faz uma operação: +, %, ==, &&, ??. A precedência decide quem é feito primeiro. Veja: Referência de Operadores e Precedência.

Operadores lógicos

&& (e), || (ou) e ! (não), que juntam condições bool. O && e o || param assim que sabem a resposta (curto-circuito). Veja: Operadores Lógicos.

out

Um parâmetro pelo qual o método devolve um valor além do retorno, como em int.TryParse(texto, out int numero). Veja: ref, out e in.

override

Na classe filha, substitui um membro virtual ou abstract da mãe. Sem virtual na mãe, dá o erro CS0506. Veja: virtual e override.

P

Parâmetro

A variável de um método que recebe um argumento: em void Saudar(string nome), nome é o parâmetro. Pode ter valor padrão (opcional) e ser passado pelo nome. Veja: Parâmetros, Parâmetros Opcionais e params.

Parse e TryParse

Converter texto em número: int.Parse("42") lança FormatException se o texto não for número; int.TryParse devolve false e é o certo para o que o usuário digita. Veja: Parse e TryParse.

partial

Divide uma classe em vários arquivos, que o compilador junta. Muito usado com código gerado por ferramentas. Veja: Classes Parciais.

Pattern matching (casamento de padrões)

Testar a forma de um valor: if (x is int n), nota is >= 0 and <= 10, pessoa is { Idade: > 18 }. Veja: Pattern Matching.

Pilha (stack)

Duas coisas no guia: a área da memória onde ficam as variáveis locais de cada método que está rodando (encher a pilha dá Stack overflow.); e a coleção Stack<T>, em que o último a entrar é o primeiro a sair. Veja: Memória, Recursão e Stack.

Polimorfismo

Uma variável de um tipo-mãe guardando um objeto de uma filha e rodando a versão da filha: num List<Conta>, cada conta mostra o seu próprio Tipo. Veja: Polimorfismo.

POO (programação orientada a objetos)

Organizar o programa em objetos que juntam dados e comportamento. Os quatro pilares: encapsulamento, herança, polimorfismo e abstração. Veja: O que é POO.

Projeto

Uma pasta com um .csproj e os arquivos .cs, criada com dotnet new console -o Nome e rodada com dotnet run. Necessário para vários arquivos, pacotes e testes. Veja: Projetos (dotnet new console) e Soluções.

Propriedade

Um membro que parece um campo de fora (conta.Saldo), mas é feito de acessadores get e set, que podem conferir regras ou calcular o valor. Veja: Propriedades.

Publicar

Gerar a versão do programa para entregar a outras pessoas, com dotnet publish: com ou sem o .NET junto, ou como programa nativo (AOT). Veja: Publicar o Programa.

Q

Queue (fila)

A coleção em que o primeiro a entrar é o primeiro a sair: Enqueue põe no fim, Dequeue tira do começo. Veja: Queue.

R

readonly

Um campo que só recebe valor na declaração ou no construtor e depois não muda. Diferente de const, o valor pode ser calculado quando o programa roda. Veja: readonly e init.

Record C# 9

Um tipo para dados, criado numa linha: record Aluno(string Nome, double Nota);. Já vem com ToString, igualdade pelo conteúdo e cópia com with. Veja: Records.

Recursão

Um método que chama a si mesmo. Precisa de um caso base que pare as chamadas, senão a pilha enche e o programa cai com Stack overflow.. Veja: Recursão.

ref

Passa a própria variável para o método, em vez de uma cópia: o que o método mudar, muda lá fora. Veja: ref, out e in.

Referência

O que uma variável de um tipo de referência guarda: o endereço do objeto no heap, e não o objeto. Copiar a variável copia o endereço. Veja: Valor × Referência.

Referências anuláveis (string?) C# 8

A conferência do compilador que separa string (nunca null) de string? (pode ser null) e avisa, com CS8602 e parentes, onde um null pode causar uma exceção. Vem ligada (Nullable = enable). Veja: Referências Anuláveis.

Reflexão

O programa examinando os próprios tipos enquanto roda: listar propriedades, achar métodos pelo nome. É assim que o JsonSerializer descobre as propriedades. Veja: Reflexão.

Regex (expressão regular)

Um padrão de texto, como \d{5}-\d{3} para um CEP, usado para validar, procurar e trocar pedaços de texto. Veja: Expressões Regulares.

Roslyn

O nome do compilador do C#, o mesmo no dotnet e no editor do guia. Veja: .NET e O Editor do Guia.

Runtime

A parte do .NET necessária para rodar programas (o CLR e a biblioteca). Para criar programas é preciso o SDK, que já inclui o runtime. Veja: .NET: SDK, Runtime e CLR.

S

SDK (Software Development Kit)

O pacote para programar em .NET: o comando dotnet, o compilador, os modelos de projeto e o runtime. No Ubuntu, sudo apt install dotnet-sdk-10.0. Veja: Instalar no Linux e .NET.

sealed

Uma classe selada não pode ter filhas; um sealed override impede as filhas de substituírem de novo. Veja: sealed.

Serializar

Transformar um objeto em texto (ou bytes) para guardar ou enviar, como em JSON; desserializar é o caminho de volta. Veja: JSON.

Sobrecarga

Vários métodos com o mesmo nome e listas de parâmetros diferentes; o compilador escolhe pela chamada. Também existe sobrecarga de operadores, como ensinar o + a somar dois objetos seus. Veja: Sobrecarga e Sobrecarga de Operadores.

Solução (.slnx)

Um arquivo que junta vários projetos (o programa, uma biblioteca, os testes) para compilar tudo de uma vez. O .NET 10 usa o formato .slnx. Veja: Soluções e Vários Projetos.

Span (Span<T>)

Uma "janela" sobre um pedaço de um array ou texto, sem copiar. Usada para código rápido. Veja: Span<T>.

Stack trace (rastro da pilha)

As linhas at … in arquivo.cs:line N de uma exceção, que mostram onde ela nasceu e quem chamou quem. Leia de cima para baixo. Veja: Exceções e Depuração.

static

Um membro que é da classe, e não de cada objeto: existe um só, usado pelo nome da classe (Math.Max, Contador.Total). Numa função local, static proíbe usar as variáveis de fora. Veja: static.

Stream

Um "fluxo" de dados lido ou escrito aos poucos, como um arquivo com StreamReader e StreamWriter. Veja: StreamReader e StreamWriter.

string

O tipo de texto: "Olá". É um tipo de referência imutável, e o == compara o conteúdo. Veja: Strings, Métodos de String e Referência de string.

StringBuilder

Uma classe para montar textos aos poucos sem criar uma string nova a cada pedaço. Num laço grande, é muito mais leve que +=. Veja: StringBuilder.

Struct

Um tipo de valor com campos e métodos, como uma classe pequena: a atribuição copia o conteúdo inteiro. int, double e DateTime são structs. Veja: Structs.

switch

Escolhe um caminho pelo valor: switch (opcao) { case "1": …; break; default: …; break; }. Em C#, um case não pode "cair" no seguinte (CS0163). Veja: switch e Expressões switch.

T

Task

Um objeto que representa um trabalho que vai terminar no futuro, com ou sem resultado (Task<int>). É o que um método async devolve. Veja: Task e async e await.

Ternário (? :)

Um if/else que devolve um valor numa linha: idade >= 18 ? "adulto" : "menor". Veja: Operador Ternário.

Testes automatizados

Código que confere outro código: um projeto xUnit com métodos [Fact] e Assert.Equal, rodados com dotnet test. Veja: Testes (xUnit).

this

Dentro de uma classe, o próprio objeto que está executando o método: this.nome = nome;. Veja: this.

Thread

Uma linha de execução: o programa começa com uma, e pode criar outras para fazer coisas ao mesmo tempo. Na prática, prefira Task. Veja: Threads e Parallel e PLINQ.

throw

Lança uma exceção: throw new ArgumentException("…");. Dentro de um catch, throw; sozinho relança a mesma exceção. Veja: throw.

Tipo

O que uma variável pode guardar e o que dá para fazer com ela: int, double, string, bool ou uma classe sua. Em C#, o tipo de uma variável nunca muda. Veja: Tipos de Dados e Tipos e Limites.

Tipo de valor × tipo de referência

Tipos de valor (int, bool, structs, enums) guardam o próprio valor, e a atribuição copia. Tipos de referência (classes, string, arrays) guardam o endereço do objeto, e a atribuição copia o endereço. Veja: Valor × Referência.

try

O bloco com o código que pode lançar uma exceção, seguido de catch e/ou finally. Veja: try e catch.

Tupla

Vários valores juntos sem criar um tipo: (string Nome, int Idade) pessoa = ("Ana", 31);. Bom para um método devolver mais de um valor. Veja: Tuplas.

U

using (diretiva)

No topo do arquivo, using System.Text.Json; deixa usar os tipos daquele namespace sem o nome completo. Os projetos já trazem vários using implícitos. Veja: Namespaces e using.

using (instrução)

using (var arquivo = …) { … } ou using var arquivo = …; chamam o Dispose no fim, fechando o recurso mesmo com exceção. Veja: using e IDisposable.

UTF-8

A codificação de texto padrão do .NET e do Linux, em que letras acentuadas ocupam mais de um byte. Salve os arquivos .cs em UTF-8. Veja: Arquivos e Editores e IDEs.

V

var

Deixa o compilador descobrir o tipo pelo valor: var nome = "Ana"; é string. Não é um tipo "solto": o tipo continua fixo. Veja: Inferência com var.

Variável

Um espaço da memória com nome e tipo, que guarda um valor: int idade = 31;. Veja: Variáveis.

virtual

Marca um membro da classe-mãe que as filhas podem substituir com override. Veja: virtual e override.

void

"Nada": o tipo de retorno de um método que não devolve valor. Veja: Métodos e Valor de Retorno.

W

WebAssembly

Um formato que deixa o navegador rodar programas compilados. O editor do guia roda o .NET em WebAssembly, por isso compila e executa C# de verdade sem instalar nada. Veja: O Editor do Guia.

Where

O método LINQ que filtra: produtos.Where(p => p.Preco < 10) fica só com os que passam na condição. Veja: Filtrar e Projetar (Where, Select).

while

O laço que repete enquanto a condição for verdadeira, testando antes de cada volta (pode não rodar nenhuma). Veja: while.

with

Cria uma cópia de um record (ou struct) com algumas propriedades trocadas: bruno with { Nota = 8 }. Veja: Records.

Y

yield return

Faz um método entregar os itens de uma sequência um por vez, pausando entre um e outro. O foreach puxa o próximo quando precisa. Veja: Iteradores (yield return).

E agora?

Quer testar o que você sabe? Faça o Quiz, com 40 perguntas dos três níveis. Para ver os termos funcionando juntos, siga um dos Projetos.