C# Operadores

Operadores são os símbolos que fazem contas e comparações: +, ==, &&, ??… Esta página traz todos os operadores do C# 14 em tabelas: primeiro a precedência (quem é calculado primeiro numa expressão com vários), depois cada grupo, com exemplo e resultado. Para aprender com calma, comece por Operadores Aritméticos e Precedência.

Todos os resultados vêm dos programas desta página, rodados no dotnet 10.0.112 da máquina da Ana (pasta ~/cs/op, cultura pt-BR) e no editor do guia, que deram a mesma saída.

Atalhos: Precedência · Aritméticos · Atribuição · ++ e -- · Comparação · Lógicos · Bits · null · Tipos · Índices e intervalos · Outros · Armadilhas · Experimente

Tabela de precedência e associatividade

Numa expressão com vários operadores, os de cima da tabela são calculados antes dos de baixo, como a multiplicação antes da soma na escola. Na mesma linha, a associatividade decide: "esquerda → direita" quer dizer que 10 - 4 - 3 é (10 - 4) - 3; "direita → esquerda" quer dizer que a = b = 7 é a = (b = 7).

Veja a tabela funcionando. Cada linha mostra a expressão e o resultado:

// precedencia.cs — quem é calculado primeiro
int a, b;
string? nada = null, vazio = null;

Console.WriteLine($"2 + 3 * 4       = {2 + 3 * 4}");
Console.WriteLine($"(2 + 3) * 4     = {(2 + 3) * 4}");
Console.WriteLine($"10 - 4 - 3      = {10 - 4 - 3}");
Console.WriteLine($"100 / 10 / 5    = {100 / 10 / 5}");
Console.WriteLine($"2 * 3 % 4       = {2 * 3 % 4}");
Console.WriteLine($"-2 * -3         = {-2 * -3}");
Console.WriteLine($"1 << 2 + 1      = {1 << 2 + 1}");
Console.WriteLine($"8 > 5 == true   = {8 > 5 == true}");
Console.WriteLine($"true || false && false = {true || false && false}");
Console.WriteLine($"(true || false) && false = {(true || false) && false}");
Console.WriteLine($"6 & 3 | 8       = {6 & 3 | 8}");
Console.WriteLine($"nada ?? vazio ?? \"padrão\" = {nada ?? vazio ?? "padrão"}");
Console.WriteLine($"5 > 3 ? \"sim\" : \"não\" = {(5 > 3 ? "sim" : "não")}");
a = b = 7;
Console.WriteLine($"a = b = 7       → a = {a}, b = {b}");
a = 10;
a += b *= 2;
Console.WriteLine($"a += b *= 2     → a = {a}, b = {b}");
int i = 5;
int r = i++ + ++i;
Console.WriteLine($"i++ + ++i (i=5) → {r}, e i = {i}");
int[] v = [10, 20, 30];
Console.WriteLine($"v[^1] * 2       = {v[^1] * 2}");
Console.WriteLine($"-v[0] + v[1]    = {-v[0] + v[1]}");

$ dotnet run precedencia.cs
2 + 3 * 4       = 14
(2 + 3) * 4     = 20
10 - 4 - 3      = 3
100 / 10 / 5    = 2
2 * 3 % 4       = 2
-2 * -3         = 6
1 << 2 + 1      = 8
8 > 5 == true   = True
true || false && false = True
(true || false) && false = False
6 & 3 | 8       = 10
nada ?? vazio ?? "padrão" = padrão
5 > 3 ? "sim" : "não" = sim
a = b = 7       → a = 7, b = 7
a += b *= 2     → a = 24, b = 14
i++ + ++i (i=5) → 12, e i = 7
v[^1] * 2       = 60
-v[0] + v[1]    = 10

As tabelas de grupo a seguir usam este programa. Cada linha da saída corresponde a uma tabela:

// opers.cs — um exemplo de cada grupo
int x = 17, y = 5;
Console.WriteLine($"{x + y} {x - y} {x * y} {x / y} {x % y} {-x}");
Console.WriteLine($"{17.0 / 5} {17m / 5} {-17 / 5} {-17 % 5}");
int c = 10;
c += 5; Console.Write($"{c} ");
c -= 3; Console.Write($"{c} ");
c *= 2; Console.Write($"{c} ");
c /= 4; Console.Write($"{c} ");
c %= 4; Console.WriteLine(c);
int n = 5;
Console.WriteLine($"{n++} {n} {++n} {n--} {--n}");
Console.WriteLine($"{x == y} {x != y} {x < y} {x > y} {x <= 17} {x >= 18}");
bool t = true, f = false;
Console.WriteLine($"{t && f} {t || f} {!t} {t & f} {t | f} {t ^ f} {t ^ t}");
Console.WriteLine($"{6 & 3} {6 | 3} {6 ^ 3} {~6} {1 << 4} {-16 >> 2} {-16 >>> 28}");
string? nome = null;
Console.WriteLine($"[{nome?.Length}] [{nome ?? "sem nome"}] [{nome?.ToUpper() ?? "?"}]");
nome ??= "Ana";
Console.WriteLine($"{nome} {nome!.Length}");
object o = "texto";
Console.WriteLine($"{o is string} {o is int} {(o as string)?.Length} {typeof(string).Name} {sizeof(long)} {nameof(nome)}");
Console.WriteLine($"{(int)3.7} {(double)7 / 2} {default(int)}");
int[] v = [10, 20, 30, 40, 50];
Console.WriteLine($"{v[^1]} {v[^2]} {string.Join(",", v[1..3])} {string.Join(",", v[..2])} {string.Join(",", v[3..])}");
Func<int, int> dobro = k => k * 2;
Console.WriteLine(dobro(21));
string tamanho = x switch { < 10 => "pequeno", < 100 => "médio", _ => "grande" };
Console.WriteLine(tamanho);

$ dotnet run opers.cs
22 12 85 3 2 -17
3,4 3,4 -3 -2
15 12 24 6 2
5 6 7 7 5
False True False True True False
False True False False True True False
2 7 5 -7 16 -4 15
[] [sem nome] [?]
Ana 3
True False 5 String 8 nome
3 3,5 0
50 40 20,30 10,20 40,50
42
médio

Aritméticos

Inteiro dividido por zero lança DivideByZeroException; double dividido por zero dá ∞ ou NaN. Detalhes em Tipos e Limites.

Atribuição

++ e --

Sozinho numa linha (n++;), tanto faz a forma. A diferença só aparece quando o valor é usado na mesma expressão. Aula: ++ e --.

Comparação

Para textos, == compara o conteúdo ("ana" == "Ana" é False); para ignorar maiúsculas, string.Equals(a, b, StringComparison.OrdinalIgnoreCase) (veja string e StringBuilder). Para objetos de classe, == compara se é o mesmo objeto, a não ser que a classe defina outra coisa (records comparam os campos). Aula: A Classe object.

Lógicos (com bool)

O atalho do && é o que torna seguro escrever texto != null && texto.Length > 0: se texto é null, o Length nem é lido.

Bits (com inteiros)

Os operadores de bits aparecem em enums com [Flags], em permissões e em formatos de arquivo. Para o dia a dia, os lógicos com bool bastam.

Operadores de null

A atribuição com ?. é nova no C# 14 (antes, só dava para ler com ?.):

// C# 14: atribuição com ?.
Cliente? semCliente = null;
Cliente? cliente = new();
semCliente?.Nome = "Bruno";     // não faz nada: semCliente é null
cliente?.Nome = "Ana";          // atribui: cliente não é null
Console.WriteLine($"[{semCliente?.Nome}] [{cliente?.Nome}]");

class Cliente { public string Nome { get; set; } = ""; }

$ dotnet run nullassign.cs
[] [Ana]

Operadores de tipo e conversão

Repare no (double)7 / 2: o cast (linha 2 da precedência) vem antes da divisão (linha 5). Primeiro o 7 vira 7.0, depois divide, e o resultado é 3,5. Já (double)(7 / 2) daria 3: a divisão de inteiros acontece antes.

Índices e intervalos

Outros operadores

Suas classes podem definir o que +, ==, < e outros fazem com elas: aula Sobrecarga de Operadores.

Armadilhas

string nome = "Ana";
int idade = 29;
Console.WriteLine("Idade: " + idade + 1);
Console.WriteLine("Idade: " + (idade + 1));
Console.WriteLine(1 + 2 + " anos");
Console.WriteLine(nome + 1 + 2);

$ dotnet run e4.cs
Idade: 291
Idade: 30
3 anos
Ana12

Experimente

int prova1 = 7;
int prova2 = 9;
int media = prova1 + prova2 / 2;
Console.WriteLine($"Média: {media}");

int prova1 = 7;
int prova2 = 9;
int media = (prova1 + prova2) / 2;
Console.WriteLine($"Média: {media}");

int a = 2, b = 3, c = 4;
Console.WriteLine(a + b * c);
Console.WriteLine((a + b) * c);
Console.WriteLine(a * b % c);
Console.WriteLine(a < b == b < c);
Console.WriteLine(a > b || b < c && c > 10);
Console.WriteLine("Total: " + a + b);
Console.WriteLine($"Total: {a + b}");
string? apelido = null;
Console.WriteLine(apelido ?? "sem apelido");

Resumo

• São 17 níveis de precedência. O essencial: primários (x.y, f(), a[i], x++), unários (-x, !x, cast), * / %, + -, comparações, ==, &&, ||, ??, ?: e, por último, a atribuição e o =>.
• Quase todos vão da esquerda para a direita; a atribuição, o ?? e o ?: vão da direita para a esquerda.
• Divisão entre inteiros corta; % é o resto.
• && e || param assim que sabem a resposta; & e | calculam os dois lados.
• ?., ?? e ??= tratam o null; no C# 14, x?.y = valor também atribui.
• Na dúvida, parênteses.