Operadores e expressões C#

O C# fornece vários operadores. Muitos deles são compatíveis com os tipos internos e permitem que você execute operações básicas com valores desses tipos. Esses operadores incluem os seguintes grupos:

• Operadores aritméticos que executam operações aritméticas com operandos numéricos
• Operadores de comparação que comparam operandos numéricos
• Operadores lógicos boolianos que executam operações lógicas com bool operandos
• Operadores bit a bit e shift que executam operações bit a bit ou shift com operandos dos tipos integrais
• Operadores de igualdade que verificam se seus operandos são iguais ou não

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. A precedência e a associatividade do operador 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 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 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#:

  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 do operador

Em uma expressão com vários operadores, os operadores com precedência mais alta são avaliados antes dos operadores com precedência inferior. No exemplo a seguir, a multiplicação é executada primeiro porque tem precedência maior 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 como a mais baixa. Os operadores dentro de cada linha têm a mesma precedência.

Para obter informações sobre a precedência de combinadores de padrões lógicos, consulte a precedência e a ordem de verificação da seção 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 na qual 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 associação nula, todos os operadores binários são associativos à esquerda. Por exemplo, a + b - c é avaliado como (a + b) - c.
• Os operadores associativos à direita são avaliados na ordem da direita para a esquerda. Os operadores de atribuição, os operadores de associação nula, lambdas e o operador ?:condicional são associativos à direita. Por exemplo, x = y = z é avaliado como x = (y = z).

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 do operando

Não relacionados à precedência e associatividade do operador, 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:

Normalmente, todos os operandos de operador são avaliados. No entanto, alguns operadores avaliam 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 and () e OR (&&||) lógicos condicionais, os operadores ?? de agrupamento nulo e ??=os operadores?. condicionais nulos 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#:

• Expressões
• Operadores

Consulte também

• Sobrecarga de operador
• Árvores de expressão