Operadores de C#

Operadores C#

En este artículo, aprenderemos todo sobre los diferentes tipos de operadores en el lenguaje de programación C# y cómo usarlos.

Los operadores son símbolos que se utilizan para realizar operaciones en los operandos. Los operandos pueden ser variables y/o constantes.

Por ejemplo , en 2+3 , + es un operador que se utiliza para realizar operaciones de suma, mientras que 2 y 3 son operandos.

Los operadores se utilizan para manipular variables y valores en un programa. C# admite varios operadores que se clasifican según el tipo de operaciones que realizan.

1. Operador de asignación básica

El operador de asignación básico (=) se utiliza para asignar valores a las variables. Por ejemplo,

double x;
x = 50.05;

Aquí, 50,05 se asigna a x.

Ejemplo 1:Operador de asignación básico

using System;

namespace Operator
{
	class AssignmentOperator
	{
		public static void Main(string[] args)
		{
			int firstNumber, secondNumber;
			// Assigning a constant to variable
			firstNumber = 10;
			Console.WriteLine("First Number = {0}", firstNumber);

			// Assigning a variable to another variable
			secondNumber = firstNumber;
			Console.WriteLine("Second Number = {0}", secondNumber);
		}
	}
}

Cuando ejecutamos el programa, la salida será:

First Number = 10
Second Number = 10

Este es un ejemplo simple que demuestra el uso del operador de asignación.

Es posible que haya notado el uso de corchetes { } en el ejemplo. Discutiremos sobre ellos en formato de cadena . Por ahora, solo ten en cuenta que {0} se reemplaza por la primera variable que sigue a la cadena, {1} es reemplazada por la segunda variable y así sucesivamente.

2. Operadores Aritméticos

Los operadores aritméticos se utilizan para realizar operaciones aritméticas como sumas, restas, multiplicaciones, divisiones, etc.

Por ejemplo,

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

Operadores aritméticos de C#
Operador	Nombre del operador	Ejemplo
+	Operador de suma	6 + 3 se evalúa como 9
-	Operador de resta	10 - 6 se evalúa como 4
*	Operador de multiplicación	4 * 2 se evalúa como 8
/	Operador de división	10 / 5 se evalúa como 2
%	Operador de módulo (resto)	16 % 3 se evalúa como 1

Ejemplo 2:Operadores aritméticos

using System;
 
namespace Operator
{
	class ArithmeticOperator
	{
		public static void Main(string[] args)
		{
			double firstNumber = 14.40, secondNumber = 4.60, result;
			int num1 = 26, num2 = 4, rem;

			// Addition operator
			result = firstNumber + secondNumber;
			Console.WriteLine("{0} + {1} = {2}", firstNumber, secondNumber, result);

			// Subtraction operator
			result = firstNumber - secondNumber;
			Console.WriteLine("{0} - {1} = {2}", firstNumber, secondNumber, result);

			// Multiplication operator
			result = firstNumber * secondNumber;
			Console.WriteLine("{0} * {1} = {2}", firstNumber, secondNumber, result);

			// Division operator
			result = firstNumber / secondNumber;
			Console.WriteLine("{0} / {1} = {2}", firstNumber, secondNumber, result);

			// Modulo operator
			rem = num1 % num2;
			Console.WriteLine("{0} % {1} = {2}", num1, num2, rem);
		}
	}
}

Cuando ejecutamos el programa, la salida será:

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

Las operaciones aritméticas se llevan a cabo en el ejemplo anterior. Las variables pueden ser reemplazadas por constantes en las sentencias. Por ejemplo,

result = 4.5 + 2.7 ; // result will hold 7.2
result = firstNumber - 3.2; // result will hold 11.2

3. Operadores relacionales

Los operadores relacionales se utilizan para comprobar la relación entre dos operandos. Si la relación es verdadera el resultado será true , de lo contrario resultará en false .

Los operadores relacionales se utilizan en la toma de decisiones y bucles.

Operadores relacionales de C#
Operador	Nombre del operador	Ejemplo
==	Igual a	6 ==4 se evalúa como falso
>	Mayor que	3> -1 se evalúa como verdadero
<	Menos de	5 <3 se evalúa como falso
>=	Mayor o igual que	4>=4 se evalúa como verdadero
<=	Menor o igual que	5 <=3 se evalúa como falso
!=	No es igual a	10 !=2 se evalúa como verdadero

Ejemplo 3:Operadores relacionales

using System;
 
namespace Operator
{
	class RelationalOperator
	{
		public static void Main(string[] args)
		{
			bool result;
			int firstNumber = 10, secondNumber = 20;

			result = (firstNumber==secondNumber);
			Console.WriteLine("{0} == {1} returns {2}",firstNumber, secondNumber, result);

			result = (firstNumber > secondNumber);
			Console.WriteLine("{0} > {1} returns {2}",firstNumber, secondNumber, result);

			result = (firstNumber < secondNumber);
			Console.WriteLine("{0} < {1} returns {2}",firstNumber, secondNumber, result);

			result = (firstNumber >= secondNumber);
			Console.WriteLine("{0} >= {1} returns {2}",firstNumber, secondNumber, result);

			result = (firstNumber <= secondNumber);
			Console.WriteLine("{0} <= {1} returns {2}",firstNumber, secondNumber, result);

			result = (firstNumber != secondNumber);
			Console.WriteLine("{0} != {1} returns {2}",firstNumber, secondNumber, result);
		}
	}
}

Cuando ejecutamos el programa, la salida será:

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

4. Operadores Lógicos

Los operadores lógicos se utilizan para realizar operaciones lógicas como and , or . Los operadores lógicos operan en expresiones booleanas (true y false ) y devuelve valores booleanos. Los operadores lógicos se utilizan en la toma de decisiones y bucles.

Así es como se evalúa el resultado para el AND lógico y OR operadores.

Operadores lógicos de C#
Operando 1	Operando 2	O (\|\|)	Y (&&)
verdadero	verdadero	verdadero	verdadero
verdadero	falso	verdadero	falso
falso	verdadero	verdadero	falso
falso	falso	falso	falso

En palabras simples, la tabla se puede resumir como:

Si uno de los operandos es verdadero, el OR el operador lo evaluará a true .
Si uno de los operandos es falso, el AND el operador lo evaluará a false .

Ejemplo 4:Operadores Lógicos

using System;
 
namespace Operator
{
	class LogicalOperator
	{
		public static void Main(string[] args)
		{
			bool result;
			int firstNumber = 10, secondNumber = 20;

			// OR operator
			result = (firstNumber == secondNumber) || (firstNumber > 5);
			Console.WriteLine(result);

			// AND operator
			result = (firstNumber == secondNumber) && (firstNumber > 5);
			Console.WriteLine(result);
		}
	}
}

Cuando ejecutamos el programa, la salida será:

True
False

5. Operadores unarios

A diferencia de otros operadores, los operadores unarios operan en un solo operando.

Operadores unarios de C#
Operador	Nombre del operador	Descripción
+	Unario Plus	Deja el signo del operando como está
-	Menos unario	Invierte el signo del operando
++	Incremento	Incrementar valor en 1
--	Decremento	Reducir el valor en 1
!	Negación Lógica (No)	Invierte el valor de un booleano

Ejemplo 5:Operadores unarios

using System;
 
namespace Operator
{
	class UnaryOperator
	{
		public static void Main(string[] args)
		{
			int number = 10, result;
			bool flag = true;

			result = +number;
			Console.WriteLine("+number = " + result);

			result = -number;
			Console.WriteLine("-number = " + result);

			result = ++number;
			Console.WriteLine("++number = " + result);

			result = --number;
			Console.WriteLine("--number = " + result);

			Console.WriteLine("!flag = " + (!flag));
		}
	}
}

Cuando ejecutamos el programa, la salida será:

+number = 10
-number = -10
++number = 11
--number = 10
!flag = False

El incremento (++) y decrementar (--) Los operadores se pueden utilizar como prefijo y posfijo. Si se usa como prefijo, el cambio de valor de la variable se ve en la misma línea y si se usa como sufijo, el cambio de valor de la variable se ve en la siguiente línea. Esto quedará claro con el siguiente ejemplo.

Ejemplo 6:Operadores Post y Pre Incremento en C#

using System;
 
namespace Operator
{
	class UnaryOperator
	{
		public static void Main(string[] args)
		{
			int number = 10;

			Console.WriteLine((number++));
			Console.WriteLine((number));

			Console.WriteLine((++number));
			Console.WriteLine((number));
		}
	}
}

Cuando ejecutamos el programa, la salida será:

Podemos ver el efecto de usar ++ como prefijo y posfijo. Cuando ++ se usa después del operando, el valor se evalúa primero y luego se incrementa en 1 . De ahí la declaración

Console.WriteLine((number++));

imprime 10 en lugar de 11 . Después de imprimir el valor, el valor del número se incrementa en 1 .

El proceso es opuesto cuando ++ se usa como prefijo. El valor se incrementa antes de imprimir. De ahí la declaración

Console.WriteLine((++number));

imprime 12 .

El caso es el mismo para el operador de decremento (--) .

6. Operador Ternario

El operador ternario ? : opera en tres operandos. Es una abreviatura de if-then-else declaración. El operador ternario se puede utilizar de la siguiente manera:

variable = Condition? Expression1 : Expression2;

El operador ternario funciona de la siguiente manera:

Si la expresión indicada por Condición es true , el resultado de Expresión1 se asigna a la variable.
Si es false , el resultado de Expresión2 se asigna a la variable.

Ejemplo 7:Operador Ternario

using System;
 
namespace Operator
{
	class TernaryOperator
	{
		public static void Main(string[] args)
		{
			int number = 10;
			string result;

			result = (number % 2 == 0)? "Even Number" : "Odd Number";
			Console.WriteLine("{0} is {1}", number, result);
		}
	}
}

Cuando ejecutamos el programa, la salida será:

10 is Even Number

Para obtener más información, visite Operador ternario de C# .

7. Operadores Bitwise y Bit Shift

Los operadores bit a bit y de desplazamiento de bits se utilizan para realizar operaciones de manipulación de bits.

Operadores C# Bitwise y Bit Shift
Operador	Nombre del operador
~	Complemento bit a bit
&	Bitbit Y
\|	Bitbit O
^	Exclusivo bit a bit O
<	Desplazamiento a la izquierda bit a bit
>>	Desplazamiento a la derecha bit a bit

Ejemplo 8:Operador Bitwise y Bit Shift

using System;
 
namespace Operator
{
	class BitOperator
	{
		public static void Main(string[] args)
		{
			int firstNumber = 10;
			int secondNumber = 20;
			int result;

			result = ~firstNumber;
			Console.WriteLine("~{0} = {1}", firstNumber, result);

			result = firstNumber & secondNumber;
			Console.WriteLine("{0} & {1} = {2}", firstNumber,secondNumber, result);

			result = firstNumber | secondNumber;
			Console.WriteLine("{0} | {1} = {2}", firstNumber,secondNumber, result);

			result = firstNumber ^ secondNumber;
			Console.WriteLine("{0} ^ {1} = {2}", firstNumber,secondNumber, result);

			result = firstNumber << 2;
			Console.WriteLine("{0} << 2 = {1}", firstNumber, result);

			result = firstNumber >> 2;
			Console.WriteLine("{0} >> 2 = {1}", firstNumber, result);
		}
	}
}

Cuando ejecutamos el programa, la salida será:

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

Para obtener más información, visite Operador C# Bitwise y Bit Shift .

8. Operadores de asignación compuesta

Operadores de asignación compuesta de C#
Operador	Nombre del operador	Ejemplo	Equivalente a
+=	Asignación adicional	`x += 5`	`x = x + 5`
-=	Asignación de Resta	`x -= 5`	`x = x - 5`
*=	Tarea 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`
&=	Bitbit AND Asignación	`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 turno a la izquierda	`x <<= 5`	`x = x << 5`
>>=	Asignación de desplazamiento a la derecha	`x >>= 5`	`x = x >> 5`
=>	Operador Lambda	`x => x*x`	`Returns x*x`

Ejemplo 9:Operador de asignación compuesto

using System;
 
namespace Operator
{
	class BitOperator
	{
		public static void Main(string[] args)
		{
			int number = 10;

			number += 5;
			Console.WriteLine(number);

			number -= 3;
			Console.WriteLine(number);

			number *= 2;
			Console.WriteLine(number);

			number /= 3;
			Console.WriteLine(number);

			number %= 3;
			Console.WriteLine(number);

			number &= 10;
			Console.WriteLine(number);

			number |= 14;
			Console.WriteLine(number);

			number ^= 12;
			Console.WriteLine(number);

			number <<= 2;
			Console.WriteLine(number);

			number >>= 3;
			Console.WriteLine(number);
		}
	}
}

Cuando ejecutamos el programa, la salida será:

Hablaremos sobre operadores Lambda en un tutorial posterior.

Variables de C# y tipos de datos (primitivos) Asociatividad y precedencia de operadores de C#

Lenguaje C