Share via

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

  • Artigo

C# fornece uma série de operadores. Muitos deles são suportados pelos tipos incorporados e permitem-lhe realizar operações básicas com valores desses tipos. Esses operadores incluem os seguintes grupos:

Normalmente, pode sobrecarregar esses operadores, ou seja, especificar o comportamento do operador para os operands de um tipo definido pelo utilizador.

As expressões mais simples de C# são literais (por exemplo, números inteiros e números reais ) e nomes de variáveis. Pode combiná-las em expressões complexas utilizando operadores. A precedência e a associatividade do operador determinam a ordem em que as operações de expressão são realizadas. Pode utilizar parênteses para alterar a ordem de avaliação imposta pela precedência e associatividade do operador.

No seguinte código, 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);

Tipicamente, 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. Só pode ser usado como declaração, como mostra o seguinte exemplo:

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

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

  • Expressões de cordas interpoladas que fornecem sintaxe conveniente para criar cordas 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 lhe 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 lhe permitem utilizar as capacidades 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 corporal de expressão para fornecer uma definição concisa para um método, construtor, propriedade, indexante ou finalizador.

Precedência de operadores

Numa expressão com vários operadores, os operadores com maior precedência são avaliados perante os operadores com menor precedência. No exemplo seguinte, a multiplicação é realizada em primeiro lugar porque tem uma precedência maior do que a adição:

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

Utilizar 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# a partir da maior precedência para o mais baixo. Os operadores dentro de cada linha têm a mesma precedência.

Operadores Categoria ou nome
x.y, f(x), a[i], x?.yx?[y]x++, x--, x!, novo, tipo de, verificado, não verificado, padrão, nome de, delegado, tamanho de, stackalloc, x-y> Primário
+x, -x, !x, ~x, ++x, -x, ^x, (T)x, await, &x, *x, verdadeiro e falso Unária
x.y Intervalo
mudar, com switch e with expressões
x * y, x / y, x % y Multiplicadora
x + y, x – y Aditiva
x << y, x >> y SHIFT
x < y, x > y, x <= y, x >= y, é, como Testes relacionais e de tipo
x == y, x!= y Igualdade
x & y Boolean lógico E ou pouco lógico E
x ^ y XOR lógico booleano ou XOR lógico bitwise
x | y Or lógico booleano ou pouco lógico OR
x && y Condicional E
x || y Condicional OR
x ?? y Operador de secagem nulo
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, => Declaração de atribuição e lambda

Associação do operador

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

  • Os operadores associativos à esquerda são avaliados de forma a dizer da esquerda para a direita. Com exceção dos operadores de atribuição e dos operadores de nulidade, 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 de forma a dizer da direita para a esquerda. Os operadores de atribuição, os operadores de nulo, as borras e o operador ?:condicional são associativos. Por exemplo, x = y = z é avaliado como x = (y = z).

Utilizar 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 operand

Sem relação com a precedência e a associatividade do operador, os operos numa expressão são avaliados da esquerda para a direita. Os seguintes exemplos demonstram a ordem em que os operadores e os operadores de ópera 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 operadores são avaliados. No entanto, alguns operadores avaliam os operands condicionalmente. Ou seja, o valor da ópera mais à esquerda de tal operador define se (ou quais) outros óperas devem ser avaliados. Estes operadores são os operadores lógicos e (&&) e OR (||) condicional, os operadores ?? de nulo e??=, os operadores ?. nulos e ?[]o operador ?:condicional. Para mais informações, consulte a descrição de cada operador.

Especificação linguística C#

Para mais informações, consulte as seguintes secções da especificação linguística C#:

Ver também