Operadores en C# – Guía completa de operadores en C#

Operadores en C#

Explore cada categoría de operadores en C# y aprenda a aplicarlos eficazmente en su código.

Los operadores son símbolos que realizan acciones sobre uno o más operandos —variables, constantes o expresiones. En C#, los operadores se agrupan por el tipo de operación que ejecutan, como aritméticos, lógicos, bit a bit y más.

1. Operador de asignación básico

El operador de asignación (=) almacena un valor en una variable.

double x; x = 50.05;

Ejemplo 1: Uso del operador de asignación

using System;
namespace DemoOperadores {
    class OperadorAsignacion {
        public static void Main(string[] args) {
            int primerNumero, segundoNumero;
            primerNumero = 10;
            Console.WriteLine("Primer Número = {0}", primerNumero);
            segundoNumero = primerNumero;
            Console.WriteLine("Segundo Número = {0}", segundoNumero);
        }
    }
}

Salida:

Primer Número = 10
Segundo Número = 10

2. Operadores aritméticos

Los operadores aritméticos realizan cálculos matemáticos.

int x = 5; int y = 10; int z = x + y; // z = 15

Operadores aritméticos en C#
Operador	Nombre	Ejemplo
+	Adición	6 + 3 = 9
-	Sustracción	10 - 6 = 4
*	Multiplicación	4 * 2 = 8
/	División	10 / 5 = 2
%	Módulo (resto)	16 % 3 = 1

Ejemplo 2: Operaciones aritméticas

using System;
namespace DemoOperadores {
    class OperadorAritmetico {
        public static void Main(string[] args) {
            double primerNumero = 14.40, segundoNumero = 4.60, resultado;
            int num1 = 26, num2 = 4, resto;
            resultado = primerNumero + segundoNumero;
            Console.WriteLine("{0} + {1} = {2}", primerNumero, segundoNumero, resultado);
            resultado = primerNumero - segundoNumero;
            Console.WriteLine("{0} - {1} = {2}", primerNumero, segundoNumero, resultado);
            resultado = primerNumero * segundoNumero;
            Console.WriteLine("{0} * {1} = {2}", primerNumero, segundoNumero, resultado);
            resultado = primerNumero / segundoNumero;
            Console.WriteLine("{0} / {1} = {2}", primerNumero, segundoNumero, resultado);
            resto = num1 % num2;
            Console.WriteLine("{0} % {1} = {2}", num1, num2, resto);
        }
    }
}

Salida:

14.4 + 4.6 = 19
14.4 - 4.6 = 9.8
14.4 * 4.6 = 66.24
14.4 / 4.6 = 3.1304347826087
26 % 4 = 2

3. Operadores relacionales

Estos operadores comparan dos operandos y devuelven un resultado booleano.

Operadores relacionales en C#
Operador	Nombre	Ejemplo
==	Igual a	6 == 4 → false
>	Mayor que	3 > -1 → true
<	Menor que	5 < 3 → false
>=	Mayor o igual que	4 >= 4 → true
<=	Menor o igual que	5 <= 3 → false
!=	Distinto de	10 != 2 → true

Ejemplo 3: Comprobaciones relacionales

using System;
namespace DemoOperadores {
    class OperadorRelacional {
        public static void Main(string[] args) {
            bool resultado;
            int primerNumero = 10, segundoNumero = 20;
            resultado = (primerNumero == segundoNumero);
            Console.WriteLine("{0} == {1} devuelve {2}", primerNumero, segundoNumero, resultado);
            resultado = (primerNumero > segundoNumero);
            Console.WriteLine("{0} > {1} devuelve {2}", primerNumero, segundoNumero, resultado);
            resultado = (primerNumero < segundoNumero);
            Console.WriteLine("{0} < {1} devuelve {2}", primerNumero, segundoNumero, resultado);
            resultado = (primerNumero >= segundoNumero);
            Console.WriteLine("{0} >= {1} devuelve {2}", primerNumero, segundoNumero, resultado);
            resultado = (primerNumero <= segundoNumero);
            Console.WriteLine("{0} <= {1} devuelve {2}", primerNumero, segundoNumero, resultado);
            resultado = (primerNumero != segundoNumero);
            Console.WriteLine("{0} != {1} devuelve {2}", primerNumero, segundoNumero, resultado);
        }
    }
}

Salida:

10 == 20 devuelve False
10 > 20 devuelve False
10 < 20 devuelve True
10 >= 20 devuelve False
10 <= 20 devuelve True
10 != 20 devuelve True

4. Operadores lógicos

Los operadores lógicos evalúan expresiones booleanas.

Operadores lógicos en C#
Operando 1	Operando 2	OR (\|\|)	AND (&&)
true	true	true	true
true	false	true	false
false	true	true	false
false	false	false	false

Si cualquiera de los operandos es true, el operador OR produce true.
Ambos operandos deben ser true para que AND devuelva true.

Ejemplo 4: Operadores lógicos

using System;
namespace DemoOperadores {
    class OperadorLogico {
        public static void Main(string[] args) {
            bool resultado;
            int primerNumero = 10, segundoNumero = 20;
            resultado = (primerNumero == segundoNumero) || (primerNumero > 5);
            Console.WriteLine(resultado);
            resultado = (primerNumero == segundoNumero) && (primerNumero > 5);
            Console.WriteLine(resultado);
        }
    }
}

Salida:

True
False

5. Operadores unarios

Los operadores unarios actúan sobre un solo operando.

Operadores unarios en C#
Operador	Nombre	Descripción
+	Más unario	Deja el signo sin cambios
-	Menos unario	Niega el signo
++	Incremento	Aumenta en 1
--	Decremento	Disminuye en 1
!	NO lógico	Invierte booleano

Ejemplo 5: Operadores unarios

using System;
namespace DemoOperadores {
    class OperadorUnario {
        public static void Main(string[] args) {
            int numero = 10, resultado;
            bool bandera = true;
            resultado = +numero;
            Console.WriteLine("+numero = " + resultado);
            resultado = -numero;
            Console.WriteLine("-numero = " + resultado);
            resultado = ++numero;
            Console.WriteLine("++numero = " + resultado);
            resultado = --numero;
            Console.WriteLine("--numero = " + resultado);
            Console.WriteLine("!bandera = " + (!bandera));
        }
    }
}

Salida:

+numero = 10
-numero = -10
++numero = 11
--numero = 10
!bandera = False

Ejemplo 6: Incremento prefijo vs. postfijo

using System;
namespace DemoOperadores {
    class OperadorUnario {
        public static void Main(string[] args) {
            int numero = 10;
            Console.WriteLine(numero++); // 10
            Console.WriteLine(numero);   // 11
            Console.WriteLine(++numero); // 12
            Console.WriteLine(numero);   // 12
        }
    }
}

Salida:

6. Operador ternario

El operador ternario (? :) condensa una sentencia if-else en una sola línea.

variable = Condición ? Expresión1 : Expresión2;

Si Condición es true, se evalúa Expresión1; de lo contrario se usa Expresión2.

Ejemplo 7: Uso del operador ternario

using System;
namespace DemoOperadores {
    class OperadorTernario {
        public static void Main(string[] args) {
            int numero = 10;
            string resultado = (numero % 2 == 0) ? "Número par" : "Número impar";
            Console.WriteLine("{0} es {1}", numero, resultado);
        }
    }
}

Salida:

10 es Número par

Más sobre el operador ternario en C#.

7. Operadores bit a bit y de desplazamiento

Estos operadores manipulan bits individuales de tipos integrales.

Operadores bit a bit y de desplazamiento en C#
Operador	Nombre
~	Complemento bit a bit
&	AND bit a bit
\|	OR bit a bit
^	XOR bit a bit
<<	Desplazamiento a la izquierda
>>	Desplazamiento a la derecha

Ejemplo 8: Operaciones bit a bit

using System;
namespace DemoOperadores {
    class OperadorBit {
        public static void Main(string[] args) {
            int primerNumero = 10, segundoNumero = 20, resultado;
            resultado = ~primerNumero;
            Console.WriteLine("~{0} = {1}", primerNumero, resultado);
            resultado = primerNumero & segundoNumero;
            Console.WriteLine("{0} & {1} = {2}", primerNumero, segundoNumero, resultado);
            resultado = primerNumero | segundoNumero;
            Console.WriteLine("{0} | {1} = {2}", primerNumero, segundoNumero, resultado);
            resultado = primerNumero ^ segundoNumero;
            Console.WriteLine("{0} ^ {1} = {2}", primerNumero, segundoNumero, resultado);
            resultado = primerNumero << 2;
            Console.WriteLine("{0} << 2 = {1}", primerNumero, resultado);
            resultado = primerNumero >> 2;
            Console.WriteLine("{0} >> 2 = {1}", primerNumero, resultado);
        }
    }
}

Salida:

~10 = -11
10 & 20 = 0
10 | 20 = 30
10 ^ 20 = 30
10 << 2 = 40
10 >> 2 = 2

Para mayor profundidad, visite la guía de operadores bit a bit y de desplazamiento en C#.

8. Operadores de asignación compuesta

Estos operadores combinan una operación aritmética con asignación.

Operadores de asignación compuesta en C#
Operador	Nombre	Ejemplo	Equivalente a
+=	Asignación de adición	`x += 5`	`x = x + 5`
-=	Asignación de sustracción	`x -= 5`	`x = x - 5`
*=	Asignación de multiplicación	`x *= 5`	`x = x * 5`
/=	Asignación de división	`x /= 5`	`x = x / 5`
%=	Asignación de módulo	`x %= 5`	`x = x % 5`
&=	Asignación AND bit a bit	`x &= 5`	`x = x & 5`
\|=	Asignación OR bit a bit	`x \|= 5`	`x = x \| 5`
^=	Asignación XOR bit a bit	`x ^= 5`	`x = x ^ 5`
<<=	Asignación de desplazamiento izquierdo	`x <<= 5`	`x = x << 5`
>>=	Asignación de desplazamiento derecho	`x >>= 5`	`x = x >> 5`
=>	Operador lambda	`x => x * x`	Devuelve x al cuadrado

Ejemplo 9: Uso de asignación compuesta

using System;
namespace DemoOperadores {
    class OperadorCompuesto {
        public static void Main(string[] args) {
            int numero = 10;
            numero += 5;
            Console.WriteLine(numero);
            numero -= 3;
            Console.WriteLine(numero);
            numero *= 2;
            Console.WriteLine(numero);
            numero /= 3;
            Console.WriteLine(numero);
            numero %= 3;
            Console.WriteLine(numero);
            numero &= 10;
            Console.WriteLine(numero);
            numero |= 14;
            Console.WriteLine(numero);
            numero ^= 12;
            Console.WriteLine(numero);
            numero <<= 2;
            Console.WriteLine(numero);
            numero >>= 3;
            Console.WriteLine(numero);
        }
    }
}

Salida:

Tutoriales posteriores cubrirán expresiones lambda en detalle.

Domine variables y tipos de datos primitivos en C#: Guía completa Dominando la precedencia y asociatividad de operadores en C#: Guía práctica

Lenguaje C