C#: Referência do C#

Q: P: Por que var é preferível aos tipos explícitos?

R: var reduz a verbosidade quando o tipo é óbvio a partir do contexto (por exemplo, var list = new List ()). Use tipos explícitos quando o tipo não estiver claro a partir do lado direito.

1. Referência rápida às palavras-chave do C#

Palavra-chave	Descrição
`abstract`	Declarar classe abstrata ou membro abstrato
`as`	Conversão de tipo segura, retorna null em caso de falha
`base`	Acesso a membro da classe base
`bool`	Tipo booleano (verdadeiro/falso)
`break`	Sair do loop ou do switch
`byte`	Inteiro sem sinal de 8 bits (0 a 255)
`case`	alternar rótulo de ramificação
`catch`	Interceptar exceção
`char`	Caractere Unicode (16 bits)
`checked`	Ativar verificação de estouro
`class`	Declarar classe
`const`	Declarar constante
`continue`	Pular a iteração atual do loop
`decimal`	Decimal de alta precisão de 128 bits
`default`	alternar para o ramo padrão ou inserir o valor padrão
`delegate`	Declarar tipo de delegado
`do`	loop do-while
`double`	Ponto flutuante de 64 bits com precisão dupla
`else`	ramificação if else
`enum`	Declarar enumeração
`event`	Declarar evento
`explicit`	Declarar operador de conversão explícito
`extern`	Declarar método implementado externamente
`false`	Literal booleano false
`finally`	bloco try-finally
`fixed`	Endereço variável do PIN (inseguro)
`float`	ponto flutuante de 32 bits de precisão simples
`for`	loop for
`foreach`	Percorrer uma coleção
`goto`	Salto incondicional
`if`	Verificação condicional
`implicit`	Declarar operador de conversão implícita
`in`	Contravariância genérica / iteração foreach / modificador de parâmetro
`int`	inteiro assinado de 32 bits
`interface`	Declarar interface
`internal`	Visível na montagem
`is`	Correspondência de padrões de tipos
`lock`	Bloqueio de exclusão mútua
`long`	inteiro assinado de 64 bits
`namespace`	Declarar namespace
`new`	Criar instância / ocultar membro base / restrição genérica
`null`	Literal de referência nula
`object`	Tipo base de todos os tipos
`operator`	Declarar sobrecarga de operador
`out`	Parâmetro de saída / covariância genérica
`override`	Substituir membro virtual básico
`params`	Parâmetro de comprimento variável
`private`	Acesso privado
`protected`	Acesso protegido
`public`	Acesso público
`readonly`	Campo somente leitura
`ref`	Passagem por referência
`return`	Valor de retorno
`sbyte`	inteiro assinado de 8 bits
`sealed`	Classe selada / substituição selada
`short`	inteiro assinado de 16 bits
`sizeof`	Obter o tamanho do tipo (inseguro)
`stackalloc`	Alocar memória na pilha (inseguro)
`static`	Membro estático
`string`	Tipo de referência de cadeia de caracteres Unicode
`struct`	Declarar estrutura de tipo de valor
`switch`	Seleção de múltiplas ramificações
`this`	Referência à instância atual / indexador de declaração / método de extensão
`throw`	Lançar exceção
`true`	Literal booleano true
`try`	Bloco de captura de exceção
`typeof`	Obter objeto Type
`uint`	inteiro sem sinal de 32 bits
`ulong`	inteiro sem sinal de 64 bits
`unchecked`	Desativar verificação de estouro
`unsafe`	Contexto não seguro
`ushort`	inteiro sem sinal de 16 bits
`using`	Importação de namespace / liberação de recursos
`virtual`	Declarar membro virtual
`void`	Sem valor de retorno
`volatile`	Marcar campo como não armazenado em cache de otimização
`while`	loop while

2. Referência rápida aos especificadores de formato

Especificador	Descrição	Exemplo
`D` / `d`	Número inteiro decimal	`42.ToString("D5")` → `"00042"`
`F` / `f`	Ponto fixo	`3.14.ToString("F2")` → `"3.14"`
`C` / `c`	Moeda	`1234.5.ToString("C")` → `"$1,234.50"`
`P` / `p`	Porcentagem	`0.156.ToString("P1")` → `"15.6 %"`
`E` / `e`	Notação científica	`12345.ToString("E2")` → `"1.23E+004"`
`X` / `x`	Hexadecimal	`255.ToString("X")` → `"FF"`
`G` / `g`	Geral (seleciona automaticamente a forma mais compacta)	`3.14.ToString("G")` → `"3.14"`

3. Métodos comuns para strings

Método	Descrição	Exemplo
`Length`	Obter contagem de caracteres	`"abc".Length` → `3`
`Substring(start)`	Extrair da posição inicial até a final	`"hello".Substring(2)` → `"llo"`
`Substring(start, len)`	Extrair subcadeia de comprimento especificado	`"hello".Substring(1, 3)` → `"ell"`
`Replace(old, new)`	Substituir todas as ocorrências	`"aabb".Replace("a","c")` → `"ccbb"`
`Split(separators)`	Dividir em matriz usando o separador	`"a,b,c".Split(',')` → `["a","b","c"]`
`Trim()`	Remover espaços em branco no início e no final	`" hi ".Trim()` → `"hi"`
`Contains(value)`	Se a subcadeia está contida	`"hello".Contains("ell")` → `true`
`IndexOf(value)`	Encontrar o primeiro índice de uma subcadeia	`"abcabc".IndexOf("bc")` → `1`
`LastIndexOf(value)`	Encontrar o último índice de uma subcadeia	`"abcabc".LastIndexOf("bc")` → `4`
`ToUpper()`	Converter para maiúsculas	`"Abc".ToUpper()` → `"ABC"`
`ToLower()`	Converter para letras minúsculas	`"AbC".ToLower()` → `"abc"`
`StartsWith(value)`	Se a string começa com o valor especificado	`"hello".StartsWith("he")` → `true`
`EndsWith(value)`	Se a string termina com o valor especificado	`"hello".EndsWith("lo")` → `true`
`PadLeft(total)`	Preencher à esquerda com espaços até o comprimento especificado	`"5".PadLeft(3)` → `" 5"`
`PadRight(total)`	Preencher à direita com espaços até o comprimento especificado	`"5".PadRight(3)` → `"5 "`
`Remove(start)`	Remover caracteres da posição inicial até a final	`"hello".Remove(2)` → `"he"`
`Remove(start, len)`	Remover caracteres com comprimento especificado	`"hello".Remove(1,2)` → `"hlo"`
`Insert(start, value)`	Inserir string na posição especificada	`"ab".Insert(1,"X")` → `"aXb"`
`IsNullOrEmpty(s)`	Se for nulo ou uma string vazia	`string.IsNullOrEmpty(null)` → `true`
`IsNullOrWhiteSpace(s)`	Se for nulo ou contiver apenas espaços em branco	`string.IsNullOrWhiteSpace(" ")` → `true`
`Join(sep, arr)`	Unir matrizes com separador	`string.Join("-",["a","b"])` → `"a-b"`
`Concat(a, b)`	Concatenar cadeias de caracteres	`string.Concat("x","y")` → `"xy"`
`Format(fmt, args)`	String de formatação	`string.Format("{0}+{1}={2}",1,2,3)` → `"1+2=3"`
`Compare(a, b)`	Comparar a ordem de duas sequências de caracteres	`string.Compare("a","b")` → `-1`
`Equals(a, b)`	Se for igual	`string.Equals("a","a")` → `true`
`Clone()`	Retorna a mesma referência de string	`"s".Clone()` → `"s"`
`Copy(s)`	Criar cópia da string (obsoleto)	`string.Copy("s")` → `"s"`
`ToCharArray()`	Converter em matriz de caracteres	`"abc".ToCharArray()` → `['a','b','c']`

4. Comparação entre tipos de coleção

Tipo de coleção	Espaço de nomes	Acesso	Classificável	Dinâmico	Uso típico
`Array`	`System`	Índice O(1)	Sim	Não	Armazenamento de dados de tamanho fixo e alto desempenho
`List<T>`	`System.Collections.Generic`	Índice O(1)	Sim	Sim	Lista dinâmica de uso geral
`Dictionary<K,V>`	`System.Collections.Generic`	Chave O(1)	Não	Sim	Mapeamento chave-valor e consulta rápida
`Queue<T>`	`System.Collections.Generic`	FIFO	Não	Sim	Agendamento de tarefas, fila de mensagens
`Stack<T>`	`System.Collections.Generic`	LIFO	Não	Sim	Desfazer operações, avaliação de expressões
`HashSet<T>`	`System.Collections.Generic`	Pesquisa por hash	Não	Sim	Desduplicação, operações com conjuntos
`LinkedList<T>`	`System.Collections.Generic`	Percorrimento de nós	Não	Sim	Inserção e remoção frequentes na cabeça/cauda

5. Comparação entre modificadores de acesso

Modificador	Mesma classe	Subclasse (mesmo assembly)	Não subclasse (mesmo assembly)	Subclasse (assembly diferente)	Não subclasse (assembly diferente)
`public`	✅	✅	✅	✅	✅
`private`	✅	❌	❌	❌	❌
`protected`	✅	✅	❌	✅	❌
`internal`	✅	✅	✅	❌	❌
`protected internal`	✅	✅	✅	✅	❌
`private protected`	✅	✅	❌	❌	❌

6. Referência rápida ao namespace comum

Espaço de nomes	Finalidade	Classes comuns
`System`	Tipos básicos e funcionalidades essenciais	`Console`, `Math`, `Environment`, `Convert`, `DateTime`
`System.IO`	Operações com arquivos e fluxos	`File`, `Directory`, `Path`, `StreamReader`, `StreamWriter`, `FileStream`
`System.Collections`	Coleções não genéricas	`ArrayList`, `Hashtable`, `Queue`, `Stack`
`System.Collections.Generic`	Coleções genéricas	`List<T>`, `Dictionary<K,V>`, `Queue<T>`, `Stack<T>`, `HashSet<T>`, `LinkedList<T>`
`System.Linq`	Consultas LINQ	`Enumerable`, `Queryable`
`System.Text`	Processamento e codificação de texto	`StringBuilder`, `Encoding`, `UTF8Encoding`
`System.Text.Json`	Serialização JSON	`JsonSerializer`, `JsonDocument`, `JsonNode`
`System.Threading`	Multithreading e sincronização	`Thread`, `Mutex`, `Semaphore`, `Monitor`, `CancellationToken`
`System.Threading.Tasks`	Tarefas assíncronas e paralelas	`Task`, `Task<T>`, `Parallel`, `ValueTask`
`System.Reflection`	Reflexão de tipo	`Assembly`, `Type`, `MethodInfo`, `PropertyInfo`, `FieldInfo`
`System.Text.RegularExpressions`	Expressões regulares	`Regex`, `Match`, `Group`, `Capture`
`System.Diagnostics`	Diagnóstico e gerenciamento de processos	`Process`, `Debug`, `Trace`, `Stopwatch`

7. Visão geral dos recursos por versão do C#

Versão	Ano	Principais recursos
C# 1.0	2002	Classes, estruturas, interfaces, delegados, eventos, sobrecarga de operadores, indexadores, propriedades, atributos
C# 2.0	2005	Genéricos, classes parciais, métodos anônimos, tipos nulos, iteradores, covariância e contravariância
C# 3.0	2007	LINQ, expressões lambda, métodos de extensão, tipagem implícita (var), tipos anônimos, propriedades automáticas, árvores de expressão
C# 4.0	2010	Ligação dinâmica (dynamic), parâmetros nomeados, parâmetros opcionais, covariância e contravariância genéricas
C# 5.0	2012	async/await, informações do chamador (CallerMemberName, etc.)
C# 6.0	2015	Interpolação de strings, operador condicional nulo, membros com corpo de expressão, `using static`, filtros de exceção, inicializadores de propriedades automáticas
C# 7.0	2017	Correspondência de padrões, tuplas, funções locais, variáveis `out`, separadores de dígitos, retornos por referência
C# 7.1	2017	Main assíncrono, literal padrão, nomes de tuplas inferidos
C# 7.2	2017	em parâmetros, estruturas ref, estruturas readonly, Span`<T>`
C# 7.3	2018	Correspondência de padrões aprimorada, comparação de tuplas, matrizes stackalloc
C# 8.0	2019	Tipos de referência nulos, intervalos e índices, fluxos assíncronos, métodos padrão de interface, correspondência de padrões aprimorada, declarações “using”
C# 9.0	2020	Tipos de registro, propriedades de inicialização, instruções de nível superior, correspondência de padrões aprimorada, `new` com tipo de destino, retornos covariantes
C# 10.0	2021	Usos globais, namespaces com escopo de arquivo, estrutura de registro, interpolação de strings constantes, melhorias nas funções lambda
C# 11.0	2022	Literais de string brutos, propriedades obrigatórias, atributos genéricos, padrões de lista, literais de string UTF-8
C# 12.0	2023	Construtores primários, expressões de coleção, matrizes inline, suporte a genéricos para ref struct, alias para qualquer tipo

▶ Exemplo

CSHARP

// A quick look-up snippet: keywords + format specifiers + common string methods
int n = 42;
string s = n.ToString("D5");        // format specifier: "00042"
string t = "  Hello  ".Trim();      // string method
System.Console.WriteLine($"{s} {t}");

▶ Experimente

TEXT 📖 Somente leitura

00042 Hello

❓ Perguntas Frequentes

P: Onde posso encontrar a referência oficial do C#? R: A referência oficial está no Microsoft Learn — ela abrange todos os métodos, propriedades e casos extremos.

P: Como faço para manter esta referência atualizada? R: Adicione o Microsoft Learn aos favoritos. O C# evolui anualmente; esta página aborda os recursos do C# 10 e versões posteriores.

P: Por que var é preferível aos tipos explícitos? R: var reduz a verbosidade quando o tipo é óbvio a partir do contexto (por exemplo, var list = new List<int>()). Use tipos explícitos quando o tipo não estiver claro a partir do lado direito.

📖 Resumo

Esta referência aborda as principais instruções, operadores e métodos do C#
O Microsoft Learn é a fonte oficial para casos excepcionais e novos recursos
Prefira var quando o tipo for óbvio; use tipos explícitos quando não estiver claro
Os métodos do LINQ são estáveis, mas novos métodos surgem anualmente

📝 Exercícios

Escolha três métodos que você não conheça. Leia os documentos do Microsoft Learn sobre eles. Escreva um resumo de uma linha para cada um.
Encontre um trecho do seu código que utilize tipos explícitos e em que var ficaria mais claro. Refatore-o.
Liste 5 métodos do LINQ que aceitam um predicado. Descreva quando usar cada um deles.

Equipe Técnica Web-Tutorial

Uma plataforma de tutoriais mantida por diversos desenvolvedores. Cada tutorial é escrito e revisado por profissionais da área correspondente. Trabalhamos para manter nosso conteúdo preciso e confiável — se encontrar algum problema, avise-nos.

Sobre Nós