Operadores e expressões do c# (referência C#)C# operators and expressions (C# reference)

O C# fornece vários operadores.C# provides a number of operators. Muitos deles têm suporte dos tipos internos e permitem que você execute operações básicas com valores desses tipos.Many of them are supported by the built-in types and allow you to perform basic operations with values of those types. Esses operadores incluem os seguintes grupos:Those operators include the following groups:

Normalmente, você pode sobrecarregar esses operadores, ou seja, especificar o comportamento do operador para os operandos de um tipo definido pelo usuário.Typically, you can overload those operators, that is, specify the operator behavior for the operands of a user-defined type.

As expressões C# mais simples são literais (por exemplo, números inteiros e reais ) e nomes de variáveis.The simplest C# expressions are literals (for example, integer and real numbers) and names of variables. Você pode combiná-los em expressões complexas usando operadores.You can combine them into complex expressions by using operators. A precedência de operador e a Associação determinam a ordem na qual as operações em uma expressão são executadas.Operator precedence and associativity determine the order in which the operations in an expression are performed. Você pode usar parênteses para alterar a ordem de avaliação imposta pela prioridade e pela associação dos operadores.You can use parentheses to change the order of evaluation imposed by operator precedence and associativity.

No código a seguir, exemplos de expressões estão no lado direito das atribuições:In the following code, examples of expressions are at the right-hand side of assignments:

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.Typically, an expression produces a result and can be included in another expression. Uma void chamada de método é um exemplo de uma expressão que não produz um resultado.A void method call is an example of an expression that doesn't produce a result. Ele pode ser usado apenas como uma instrução, como mostra o exemplo a seguir:It can be used only as a statement, as the following example shows:

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

Aqui estão alguns outros tipos de expressões que o C# fornece:Here are some other kinds of expressions that C# provides:

  • Expressões de cadeia de caracteres interpoladas que fornecem uma sintaxe conveniente para criar cadeias formatadas:Interpolated string expressions that provide convenient syntax to create formatted strings:

    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:Lambda expressions that allow you to create anonymous functions:

    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#:Query expressions that allow you to use query capabilities directly in 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.You can use an expression body definition to provide a concise definition for a method, constructor, property, indexer, or finalizer.

Precedência do operadorOperator precedence

Em uma expressão com vários operadores, os operadores com maior precedência são avaliados antes dos operadores com menor precedência.In an expression with multiple operators, the operators with higher precedence are evaluated before the operators with lower precedence. No exemplo a seguir, a multiplicação é executada primeiro porque tem uma precedência mais alta do que a adição:In the following example, the multiplication is performed first because it has higher precedence than addition:

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:Use parentheses to change the order of evaluation imposed by operator precedence:

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.The following table lists the C# operators starting with the highest precedence to the lowest. Os operadores em cada linha têm a mesma precedência.The operators within each row have the same precedence.

OperadoresOperators Categoria ou nomeCategory or name
x. y, f (x), a[i], x?.y , x?[y] , x + +, x--, x!, novo, typeof, Checked, desmarcado, padrão, nameof, delegate, sizeof, stackalloc, x->yx.y, f(x), a[i], x?.y, x?[y], x++, x--, x!, new, typeof, checked, unchecked, default, nameof, delegate, sizeof, stackalloc, x->y PrimárioPrimary
+ x, -x, ! x, ~ x, + + x, --x, ^ x, (T) x, Await, &x, * x, true e false+x, -x, !x, ~x, ++x, --x, ^x, (T)x, await, &x, *x, true and false UnárioUnary
x.. Iarx..y IntervaloRange
switchswitch Expressão switchswitch expression
porwith Expressão withwith expression
x * y, x / y, x % yx * y, x / y, x % y MultiplicativoMultiplicative
x + y, x – yx + y, x – y AditivaAdditive
x << y, x >> yx << y, x >> y ShiftShift
x < y, x > y, x <= y, x > = y, é, comox < y, x > y, x <= y, x >= y, is, as Teste de tipo e relacionalRelational and type-testing
x = = y, x! = yx == y, x != y IgualitárioEquality
x & y AND lógico booliano ou AND lógico bit a bitBoolean logical AND or bitwise logical AND
x ^ y XOR lógico booliano ou XOR lógico bit a bitBoolean logical XOR or bitwise logical XOR
x | y OR lógico booliano ou OR lógico bit a bitBoolean logical OR or bitwise logical OR
x && yx && y AND condicionalConditional AND
x || yx || y OR condicionalConditional OR
x ?? yx ?? y Operador de coalescência nulaNull-coalescing operator
c ? t : fc ? t : f Operador condicionalConditional operator
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, 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 lambdaAssignment and lambda declaration

Associação de operadorOperator associativity

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:When operators have the same precedence, associativity of the operators determines the order in which the operations are performed:

  • Os operadores associativos esquerdos são avaliados na ordem da esquerda para a direita.Left-associative operators are evaluated in order from left to right. Exceto para os operadores de atribuição e os operadores de União nulo, todos os operadores binários são associativos à esquerda.Except for the assignment operators and the null-coalescing operators, all binary operators are left-associative. Por exemplo, a + b - c é avaliado como (a + b) - c.For example, a + b - c is evaluated as (a + b) - c.
  • Os operadores associativos direitos são avaliados na ordem da direita para a esquerda.Right-associative operators are evaluated in order from right to left. Os operadores de atribuição, os operadores de União nula e o operador ?: condicional são associativos à direita.The assignment operators, the null-coalescing operators, and the conditional operator ?: are right-associative. Por exemplo, x = y = z é avaliado como x = (y = z).For example, x = y = z is evaluated as x = (y = z).

Use parênteses para alterar a ordem de avaliação imposta pela associação de operador:Use parentheses to change the order of evaluation imposed by operator associativity:

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

Avaliação do operandoOperand evaluation

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.Unrelated to operator precedence and associativity, operands in an expression are evaluated from left to right. Os exemplos a seguir demonstram a ordem em que os operadores e os operandos são avaliados:The following examples demonstrate the order in which operators and operands are evaluated:

ExpressionExpression Ordem de avaliaçãoOrder of evaluation
a + b a, b, +a, b, +
a + b * c a, b, c, *, +a, b, c, *, +
a / b + c * d a, b, /, c, d, *, +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.Typically, all operator operands are evaluated. No entanto, alguns operadores avaliam os operandos condicionalmente.However, some operators evaluate operands conditionally. Ou seja, o valor do operando mais à esquerda de tal operador define if (ou quais) outros operandos devem ser avaliados.That is, the value of the leftmost operand of such an operator defines if (or which) other operands should be evaluated. Esses operadores são os operadores lógicos condicional and ( && ) e or ( || ) , os operadores de União nula ?? e ??= , os operadores condicionais NULL ?. e ?[] e o operador ?: condicional .These operators are the conditional logical AND (&&) and OR (||) operators, the null-coalescing operators ?? and ??=, the null-conditional operators ?. and ?[], and the conditional operator ?:. Para obter mais informações, consulte a descrição de cada operador.For more information, see the description of each operator.

Especificação da linguagem C#C# language specification

Para obter mais informações, confira as seguintes seções da especificação da linguagem C#:For more information, see the following sections of the C# language specification:

Confira tambémSee also