Compartir a través de

Operadores y expresiones de C#

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. Estos operadores incluyen los siguientes grupos:

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

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

En el código siguiente, los ejemplos de expresiones se encuentran 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];

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

Normalmente, una expresión genera un resultado y se puede incluir en otra expresión. Una void llamada al método es un ejemplo de una expresión que no genera un resultado. Solo se puede usar como instrucción , como se muestra en el ejemplo siguiente:

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

Estos son otros tipos de expresiones que proporciona C#:

  • Expresiones de cadena interpoladas que proporcionan una sintaxis cómoda 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 las funcionalidades de consulta directamente en 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

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

Precedencia de operadores

En una expresión con varios operadores, los operadores con mayor prioridad se evalúan antes de que los operadores tengan 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 precedencia del operador:

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

En la tabla siguiente se enumeran los operadores de C# que comienzan con la prioridad más alta a la más baja. Los operadores de cada fila tienen la misma 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> Primario
+x, -x, !x, ~x, ++x, --x, ^x, (T)x, await, &x, *x, true y false Unario
x..y Intervalo
switch, con Expresiones switch y with
x * y, x / y, x % y Multiplicativo
x + y, x – y Aditivo
x y, x <<>> y, x >>> y Shift
x y, x <> y, x <= y, x >= y, is, as Comprobación de tipos y relacional
x == y, x != y Igualdad
x & y AND lógico booleano o AND lógico bit a bit
x ^ y XOR lógico booleano o XOR lógico bit a bit
x | y OR lógico booleano o OR lógicobit a bit
x&y AND condicional
x || y OR condicional
x ?? y Operador de fusión 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, x >>>= y, x ?? = y, => Declaración lambda y asignación

Para obtener información sobre la prioridad de los combinadores de patrones lógicos, consulte la sección Precedencia y orden de comprobación de patrones lógicos del artículo Patrones .

Asociatividad de operadores

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

  • Los operadores asociativos izquierdos se evalúan en orden de izquierda a derecha. Excepto para los operadores de asignación y los operadores de fusión null, todos los operadores binarios son asociativos a la izquierda. Por ejemplo, a + b - c se evalúa como (a + b) - c.
  • Los operadores asociativos derecho se evalúan en orden de derecha a izquierda. Los operadores de asignación, los operadores de fusión 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).

Importante

En una expresión del formulario P?.A0?.A1, si P es null, ni A0 se evalúan.A1 Del mismo modo, en una expresión del formulario P?.A0.A1, porque A0 no se evalúa cuando P es null, tampoco es A0.A1. Consulte la especificación del lenguaje C# para obtener más detalles.

Use paréntesis para cambiar el orden de evaluación impuesto por la asociatividad del operador:

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

No relacionado con la precedencia del operador y la asociatividad, los operandos de una expresión se evalúan de izquierda a derecha. En los ejemplos siguientes se muestra el orden en el que se evalúan los operadores y 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 operador. Sin embargo, algunos operadores evalúan operandos condicionalmente. Es decir, el valor del operando más a la izquierda de dicho operador define si se deben evaluar (o cuáles) otros operandos. Estos operadores son los operadores LÓGICOS CONDICIONALES AND () y OR (&&||), los operadores ?? de fusión null y ??=, los operadores ?. condicionales NULL y ?[], y el operador ?:condicional . Para obtener 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#:

Consulte también

  • Last updated on