Compartilhar via

Operadores e expressões C# (referência em C#)

  • Artigo

O C# fornece vários operadores. Muitos deles têm suporte pelos tipos internos e permitem que você execute operações básicas com valores desses tipos. Esses operadores incluem os seguintes grupos:

Normalmente, você pode sobrecarregar esses operadores, ou seja, especificar o comportamento do operador para os operandos de um tipo definido pelo usuário.

As expressões C# mais simples são literais (por exemplo, números inteiros e reais) e nomes de variáveis. Você pode combiná-las em expressões complexas usando operadores. O operador precedence e associativity, determinam a ordem na qual as operações em uma expressão são executadas. Você pode usar parênteses para alterar a ordem de avaliação imposta pela prioridade e pela associação dos operadores.

No código a seguir, exemplos de expressões estão no lado direito das atribuições:

int a, b, c;
a = 7;
b = a;
c = b++;
b = a + b * c;
c = a >= 100 ? b : c / 10;
a = (int)Math.Sqrt(b * b + c * c);

string s = "String literal";
char l = s[s.Length - 1];

var numbers = new List<int>(new[] { 1, 2, 3 });
b = numbers.FindLast(n => n > 1);

Normalmente, uma expressão produz um resultado e pode ser incluída em outra expressão. Uma chamada de método void é um exemplo de uma expressão que não produz um resultado. Ele pode ser usado apenas como uma instrução, como mostra o exemplo a seguir:

Console.WriteLine("Hello, world!");

Aqui estão alguns outros tipos de expressões que o C# fornece:

  • Expressões de cadeia de caracteres interpoladas que fornecem sintaxe conveniente para criar cadeias de caracteres formatadas:

    var r = 2.3;
var message = $"The area of a circle with radius {r} is {Math.PI * r * r:F3}.";
Console.WriteLine(message);
// Output:
// The area of a circle with radius 2.3 is 16.619.

  • Expressões lambda que permitem criar funções anônimas:

    int[] numbers = { 2, 3, 4, 5 };
var maximumSquare = numbers.Max(x => x * x);
Console.WriteLine(maximumSquare);
// Output:
// 25

  • Expressões de consulta que permitem que você use recursos de consulta diretamente em C#:

    var scores = new[] { 90, 97, 78, 68, 85 };
IEnumerable<int> highScoresQuery =
    from score in scores
    where score > 80
    orderby score descending
    select score;
Console.WriteLine(string.Join(" ", highScoresQuery));
// Output:
// 97 90 85

Você pode usar uma definição de corpo de expressão para fornecer uma definição concisa para um método, construtor, propriedade, indexador ou finalizador.

Precedência do operador

Em uma expressão com vários operadores, os operadores com maior precedência são avaliados antes dos operadores com menor precedência. No exemplo a seguir, a multiplicação é executada primeiro porque tem uma precedência mais alta do que a adição:

var a = 2 + 2 * 2;
Console.WriteLine(a); //  output: 6

Use parênteses para alterar a ordem de avaliação imposta pela precedência do operador:

var a = (2 + 2) * 2;
Console.WriteLine(a); //  output: 8

A tabela a seguir lista os operadores C#, começando com a precedência mais alta até a mais baixa. Os operadores em cada linha têm a mesma precedência.

Operadores Categoria ou nome
x.y, f(x), a[i], x?.y, x?[y], x++, x--, x!, new, typeof, checked, unchecked, default, nameof, delegate, sizeof, stackalloc, x->y Primário
+x, -x, !x, ~x, ++x, --x, ^x, (T)x, await, &x, *x, verdadeiro e falso Unário
x..y Intervalo
switch, com switch e expressões with
x * y, x / y, x % y Multiplicativo
x + y, x – y Aditiva
x << y, x >> y Shift
x < y, x > y, x <= y, x >= y, is, as Teste de tipo e relacional
x == y, x != y Igualitário
x & y AND lógico booliano ou AND lógico bit a bit
x ^ y XOR lógico booliano ou XOR lógico bit a bit
x | y OR lógico booliano ou OR lógico bit a bit
x && y AND condicional
x || y OR condicional
x ?? a Operador de coalescência nula
c ? t : f Operador condicional
x = y, x += y, x -= y, x *= y, x /= y, x %= y, x &= y, x |= y, x ^= y, x <<= y, x >>= y, x ??= y, => Declaração de atribuição e lambda

Associação de operador

Quando os operadores têm a mesma precedência, a associação dos operadores determina a ordem na qual as operações são executadas:

  • Os operadores associativos esquerdos são avaliados na ordem da esquerda para a direita. Com exceção dos operadores de atribuição e do operador de avaliação de nulo, todos os operadores binários são associativos esquerdos. Por exemplo, a + b - c é avaliado como (a + b) - c.
  • Os operadores associativos direitos são avaliados na ordem da direita para a esquerda. Os operadores de atribuição, o operador de avaliação de nulo, lambdas e o operador condicional?: são associativos direitos. Por exemplo, x = y = z é avaliado como x = (y = z).

Use parênteses para alterar a ordem de avaliação imposta pela associação de operador:

int a = 13 / 5 / 2;
int b = 13 / (5 / 2);
Console.WriteLine($"a = {a}, b = {b}");  // output: a = 1, b = 6

Avaliação do operando

Sem considerar a relação com a precedência e a associação de operadores, os operandos em uma expressão são avaliados da esquerda para a direita. Os exemplos a seguir demonstram a ordem em que os operadores e os operandos são avaliados:

Expression Ordem de avaliação
a + b a, b, +
a + b * c a, b, c, *, +
a / b + c * d a, b, /, c, d, *, +
a / (b + c) * d a, b, c, +, /, d, *

Normalmente, todos os operandos do operador são avaliados. Alguns operadores avaliam os operandos condicionalmente. Ou seja, o valor do operando mais à esquerda de tal operador define se (ou quais) outros operandos devem ser avaliados. Esses operadores são os operadores lógicos AND (&&) e OR (||), o operador de avaliação de nulo?? e ??=, os operadores condicionais nulos ?. e?[] e o operador condicional ?:. Para obter mais informações, consulte a descrição de cada operador.

Especificação da linguagem C#

Para obter mais informações, confira as seguintes seções da especificação da linguagem C#:

Confira também