Partilhar via

Operadores e expressões C#

C# fornece vários operadores. Muitos deles são suportados 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á-los em expressões complexas usando operadores. A precedência do operador e a associatividade determinam a ordem em que as operações em uma expressão são executadas. Você pode usar parênteses para alterar a ordem de avaliação imposta pela precedência e associatividade do operador.

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];

List<int> numbers = [..collection];
b = numbers.FindLast(n => n > 1);

Normalmente, uma expressão produz um resultado e pode ser incluída em outra expressão. Uma void chamada de método é 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 do 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 usar recursos de consulta diretamente em C#:

    int[] scores = { 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 dos operadores

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 é realizada primeiro porque tem maior precedência 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 maior precedência para a menor. Os operadores dentro de 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, aguardar, &x, *x, verdadeiro e falso Unário
x..y Alcance
interruptor, com switch e expressões with
x * y, x / y, x % y Multiplicativo
x + y, x – y Aditivo
x << y, x >> y, x >>> y Turno
x < y, x > y, x <= y, x >= y, é, como Testes relacionais e de tipo
x == y, x != y Igualdade
x & y Lógica booleana E ou lógica bitwise E
x ^ y XOR lógico booleano ou XOR lógico bitwise
x | y Lógica booleana OU ou lógica bitwise OU
x && y Condicional E
x || y OU condicional
x ?? y 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, x >>>??>> = y, => Cessão e declaração lambda

Para obter informações sobre a precedência de combinadores de padrões lógicos, consulte a seção Precedência e ordem de verificação de padrões lógicos do artigo Padrões .

Associatividade do operador

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

  • Os operadores associativos à esquerda são avaliados em ordem da esquerda para a direita. Com exceção dos operadores de atribuição e dos operadores de coalescência nulos, todos os operadores binários são associados à esquerda. Por exemplo, a + b - c é avaliado como (a + b) - c.
  • Os operadores associativos à direita são avaliados em ordem da direita para a esquerda. Os operadores de atribuição, os operadores de coalescência nula, lambdas e o operador ?:condicional são associativos à direita. Por exemplo, x = y = z é avaliado como x = (y = z).

Importante

Numa expressão da forma P?.A0?.A1, se P é null, nem A0A1 são avaliados. Da mesma forma, em uma expressão da forma P?.A0.A1, porque A0 não é avaliado quando P é nulo, também não é A0.A1. Consulte a especificação da linguagem C# para obter mais detalhes.

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

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

Avaliação de operandos

Sem relação com a precedência do operador e a associatividade, os operandos em uma expressão são avaliados da esquerda para a direita. Os exemplos a seguir demonstram a ordem na qual operadores e operandos são avaliados:

Expressão 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. No entanto, 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 condicionais AND (&&) e OR (||), os operadores ?? de coalescência nula 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, consulte as seguintes seções da especificação da linguagem C#:

Ver também

  • Last updated on