Operadores y expresiones de C# (referencia de C#)

  • Artículo

C# proporciona una serie de operadores. Muchos de ellos son compatibles con los tipos integrados y permiten realizar operaciones básicas con valores de esos tipos. Entre estos operadores se incluyen los siguientes grupos:

Normalmente, puede sobrecargar esos operadores, es decir, puede especificar el comportamiento del operador para los operandos de un tipo definido por el usuario.

Las expresiones más simples de C# son literales (por ejemplo, números enteros y reales) y nombres de variables. Puede combinarlas para crear expresiones complejas mediante el uso de operadores. La precedencia y la asociatividad de los operadores determinan el orden en el que se realizan las operaciones en una expresión. Puede usar los paréntesis para cambiar el orden de evaluación impuesto por la prioridad y la asociatividad de operadores.

En el código siguiente, se muestran ejemplos de expresiones en el lado derecho de las asignaciones:

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, una expresión genera un resultado que se puede incluir en otra expresión. Un método de llamada void es un ejemplo de expresión que no genera un resultado. Solo se puede usar como instrucción, tal como se muestra en el ejemplo siguiente:

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

A continuación se indican otros tipos de expresiones que ofrece C#:

  • Expresiones de cadenas interpoladas, que proporcionan una sintaxis práctica para crear cadenas con formato:

    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.

  • Expresiones lambda, que permiten crear funciones anónimas.

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

  • Expresiones de consulta, que permiten usar capacidades de consulta directamente en 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

Puede usar una definición de cuerpo de expresiones para proporcionar una definición concisa para un método, un constructor, una propiedad, un indexador o un finalizador.

Prioridad de operadores

En una expresión con varios operadores, los operadores con mayor prioridad se evalúan antes que los operadores con menor prioridad. En el ejemplo siguiente, la multiplicación se realiza primero porque tiene mayor prioridad que la suma:

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

Use paréntesis para cambiar el orden de evaluación impuesto por la prioridad de los operadores:

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

En la tabla siguiente se muestran los operadores de C# desde la precedencia más alta a la más baja. Los operadores de cada fila comparten la prioridad.

Operadores Categoría o nombre
x.y, f(x), a[i], x?.y, x?[y], x++, x--, x!, new, typeof, checked, unchecked, default, nameof, delegate, sizeof, stackalloc, x->y Principal
+x, -x, !x, ~x, ++x, --x, ^x, (T)x, await, &x, *x, true and false Unario
x..y Intervalo
switch, with Expresiones switch y with
x * y, x / y, x % y Multiplicativo
x + y, x – y Aditivo
x << y, x >> y Mayús
x < y, x > y, x <= y, x >= y, is, as Comprobación de tipos y relacional
x == y, x != y Igualdad
x & y Operador lógico booleano AND u operador lógico bit a bit AND
x ^ y Operador lógico booleano XOR u operador lógico bit a bit XOR
x | y Operador lógico booleano OR u operador lógico bit a bit OR
x && y AND condicional
x || y OR condicional
x ?? y Operador de uso combinado de null
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, => Asignación y declaración lambda

Asociatividad de los operadores

Cuando los operadores tienen la misma prioridad, su asociatividad determina el orden en el que se realizan las operaciones:

  • Los operadores asociativos a la izquierda se evalúan, por orden, de izquierda a derecha. A excepción de los operadores de asignación y el operador de integración nula , todos los operadores binarios son asociativos a la izquierda. Por ejemplo, a + b - c se evalúa como (a + b) - c.
  • Los operadores asociativos a la derecha se evalúan, por orden, de derecha a izquierda. Los operadores de asignación, los operadores de fusión de NULL, las expresiones lambda y el operador condicional ?: son asociativos a la derecha. Por ejemplo, x = y = z se evalúa como x = (y = z).

Use paréntesis, para cambiar el orden de evaluación impuesto por la asociatividad de los operadores:

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

Evaluación de operandos

Independientemente de la prioridad y la asociatividad de los operadores, los operandos de una expresión se evalúan de izquierda a derecha. En los siguientes ejemplos, se muestra el orden en el que se evalúan los operadores y los operandos:

Expresión Orden de evaluación
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, se evalúan todos los operandos de un operador. Sin embargo, algunos operadores evalúan los operandos de forma condicional. Esto significa que el valor del operando situado más a la izquierda de este tipo de operador define si se deben evaluar otros operandos, o bien qué operandos deben evaluarse. Estos operadores son los operadores lógicos condicionales AND (&&) y OR (||), los operadores de integración nula ?? y ??=, los operadores condicionales nulos ?. y ?[], así como el operador condicional ?:. Para más información, consulte la descripción de cada operador.

Especificación del lenguaje C#

Para más información, vea las secciones siguientes de la Especificación del lenguaje C#:

Vea también