Descubre cómo utilizar variables en C# para optimizar tu código: Guía completa
Tags: dotnet, csharp, programming, spanish
Published: 2023-04-27 22:17:01

Si estás interesado en el mundo de la programación, seguramente has escuchado hablar de C#. Este lenguaje de programación es muy popular y es utilizado por muchas empresas. En este artículo, te explicaré de manera sencilla qué son las variables en C# y cómo puedes utilizarlas para crear programas geniales. ¡Empecemos!

## Introducción a las variables en C#: ¿qué son y para qué sirven?

Cuando se programa en C#, se utilizan variables para almacenar temporalmente datos que serán utilizados en el programa. Estas variables pueden guardar diferentes tipos de datos y su valor puede cambiar a lo largo del programa.

Una variable es una zona de memoria reservada en la computadora que tiene un nombre y un tipo de dato. El nombre de la variable se utiliza para hacer referencia en el programa, y el tipo de dato indica qué tipo de información se almacenará en ella. Al asignar un valor a una variable, se guarda el valor en la memoria reservada para esa variable.


![Funcionamiento de una variable](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/p690krp2ybanfanjfbv3.png)

Posiblemente en el colegio hayas llevado ecuaciones donde tenias que encontrar el valor de una variable X. Por ejemplo, en la ecuación *y = 3x + 5*, la variable X representa un valor desconocido que debe ser determinado a partir de otros datos.

De manera similar, en programación, las variables se utilizan para almacenar valores que pueden ser desconocidos al principio pero que deben ser determinados a lo largo del programa. Por ejemplo, una variable edad podría representar la edad de un usuario de un programa, que es desconocida al principio pero que se determina a partir de los datos que proporciona el usuario.

## Tipos de variables en C#: enteros, decimales, booleanos y más.

C# es un lenguaje de programación fuertemente tipado, lo que significa que cada variable debe tener un tipo de dato definido en el momento de su declaración. Los tipos de variables más comunes en C# son los siguientes:

| Tipo de dato | Descripción |
| --- | --- |
| `bool` | Representa un valor booleano, que puede ser verdadero o falso |
| `byte` | Representa un número entero sin signo de 8 bits |
| `sbyte` | Representa un número entero con signo de 8 bits |
| `char` | Representa un carácter Unicode de 16 bits |
| `decimal` | Representa un número decimal con una precisión de 28-29 dígitos |
| `double` | Representa un número decimal de punto flotante de 64 bits |
| `float` | Representa un número decimal de punto flotante de 32 bits |
| `int` | Representa un número entero con signo de 32 bits |
| `uint` | Representa un número entero sin signo de 32 bits |
| `long` | Representa un número entero con signo de 64 bits |
| `ulong` | Representa un número entero sin signo de 64 bits |
| `object` | Representa cualquier tipo de objeto |
| `short` | Representa un número entero con signo de 16 bits |
| `ushort` | Representa un número entero sin signo de 16 bits |
| `string` | Representa una secuencia de caracteres Unicode |

Si bien C# es un lenguaje fuertemente tipado, podemos crear variables con un tipo dinámico utilizando la palabra reservada dynamic como tipo de dato. A continuación, un ejemplo de como podemos asignar a una variable diferente tipos de datos con dynamic.

```c#
dynamic variableConTipadoDinamico = "Hello";
Console.WriteLine(variableConTipadoDinamico.GetType()); // Aquí es un String
variableConTipadoDinamico = 10;
Console.WriteLine(variableConTipadoDinamico.GetType()); // Aquí es un Int
variableConTipadoDinamico = true;
Console.WriteLine(variableConTipadoDinamico.GetType()); // Aquí es un Boolean
```

## Declaración y asignación de variables en C#: cómo empezar a usarlas.

En C#, declarar y asignar variables es una tarea muy sencilla. Para declarar una variable, se utiliza la sintaxis *tipoDeDato nombreDeVariable;*. Mientras que para asignar se utiliza *nombreDeVariable = valor;*.

```c#
byte edad; // Esto es una declaración
edad = 20; // Esto es una asignación
```

¿Y si queremos declara y asignar al mismo tiempo? Podemos hacerlo en la misma línea de la siguiente forma :

```c#
byte edad = 20; // Declaración y asignación en la misma línea
```

Sin embargo, existe otra forma para crear variables cuando declaramos y asignamos su valor en la misma línea, utilizando la palabra reservada var. Esto nos ayuda a declarar variables con el tipo de dato implícito, es decir sin especificar el tipo de dato a la variable, ya que tomará el tipo de dato que se le asigne.

```c#
// Declaración explícita
string name = "Maad";
Console.WriteLine(name.GetType()); // String

// Declaración implícita
var fullname = "Maadcode";
Console.WriteLine(fullname.GetType()); // String
var edad = 21;
Console.WriteLine(edad.GetType()); // Int
```

Tener en cuenta que esta forma sólo funciona cuando declaras y asignas en la misma línea, si sólo declaras una variable usando var sin asignarle un valor tendrás un error, ya que el compilador no podrá identificar el tipo de dato.

## Operaciones con variables en C#: aritméticos, lógicos y de comparación.

En programación, las operaciones con variables son fundamentales. Aquí te mostramos cómo realizar operaciones básicas en C#.

Operadores Aritméticos : 

| Operación | Descripción | Ejemplo |
| --- | --- | --- |
| `+` | Suma dos valores. | <code>int resultado = 5 + 3; // resultado = 8</code> |
| `-` | Resta dos valores. | <code>int resultado = 7 - 2; // resultado = 5</code> |
| `*` | Multiplica dos valores. | <code>int resultado = 4 * 6; // resultado = 24</code> |
| `/` | Divide dos valores. | <code>int resultado = 15 / 3; // resultado = 5</code> |
| `%` | Obtiene el resto de una división. | <code>int resultado = 10 % 3; // resultado = 1</code> |
| `++` | Aumenta en 1. | <code>int resultado = 1; resultado++; // resultado = 2</code> |
| `--` | Reduce en 1. | <code>int resultado = 1; resultado--; // resultado = 0</code> |

Operadores Lógicos : 

| Operación | Descripción | Ejemplo |
| --- | --- | --- |
| `&&` | AND lógico. Devuelve `true` si ambas expresiones son verdaderas. | <code>bool resultado = (true && true); // resultado = true</code> |
| <code>&#124;&#124;</code> | OR lógico. Devuelve `true` si al menos una de las expresiones es verdadera. | <code>bool resultado = (true &#124;&#124; false); // resultado = true</code> |
| `!` | NOT lógico. Niega la expresión dada. | <code>bool resultado = !(true); // resultado = false</code> |


Operadores de comparación :

| Operación | Descripción | Ejemplo |
| --- | --- | --- |
| `==` | Igualdad. Devuelve `true` si ambas expresiones son iguales. | <code>bool resultado = (10 == 10); // resultado = true</code> |
| `!=` | Desigualdad. Devuelve `true` si ambas expresiones son diferentes. | <code>bool resultado = (10 != 15); // resultado = true</code> |
| `<` | Menor que. Devuelve `true` si el valor de la izquierda es menor al de la derecha. | <code>bool resultado = (10 < 15); // resultado = true</code> |
| `>` | Mayor que. Devuelve `true` si el valor de la izquierda es mayor al de la derecha. | <code>bool resultado = (15 > 10); // resultado = true</code> |
| `<=` | Menor o igual que. Devuelve `true` si el valor de la izquierda es menor o igual al de la derecha. | <code>bool resultado = (15 <= 15); // resultado = true</code> |
| `>=` | Mayor o igual que. Devuelve `true` si el valor de la izquierda es mayor o igual al de la derecha. | <code>bool resultado = (10 >= 10); // resultado = true</code> |

## Reglas y convenciones para nombrar variables en C#: buenas prácticas a tener en cuenta.

Cuando estás programando en C#, es muy importante nombrar tus variables de forma clara y concisa para que otros desarrolladores puedan entender fácilmente el código. Para hacerlo bien, hay algunas reglas y convenciones que debes seguir.

### 1. Utilizar nombres descriptivos

Es recomendable utilizar nombres de variables que sean descriptivos y que den una idea clara del propósito de la variable. Esto ayudará a otros desarrolladores a entender rápidamente lo que la variable representa, lo que puede mejorar la legibilidad del código.

```c#
// Supongamos que queremos aplicar un descuento de 5% a un producto cuando su precio es mayor a 1200
var dscto = 0.05;
var prod = 1500d; // Usamos la letra d al final del número para indicar que es un double, sino lo agregas creara la variable tipo int, la otra opción es que indiques explicitamente que es un double
var total = 0d;
if(prod >= 1200)
    total = prod - (prod * dscto);
else
    total = prod;
Console.WriteLine(total);
```

Con el código anterior no es claro a que se refiere cada variable, tendríamos que leer todo el código y debuggear para entender, lo cual tomaría tiempo innecesario. Entonces, ¿cómo podemos hacer este código más legible? Veamos.

```c#
var porcentajeDescuento = 0.05;
var precioDeProducto = 1500d;
var totalAPagar = precioDeProducto;
if(precioDeProducto >= 1200)
    totalAPagar -=  (precioDeProducto * porcentajeDescuento);
Console.WriteLine(totalAPagar);
```

Ya quedo mucho mejor. Sin embargo, ese número 1200 que se encuentra en la condicional, es número mágico y debemos evitarlo. Un número mágico es un valor que representa algún dato significativo para el negocio pero es posible que otro desarrollador nuevo no comprenda dicho valor si no tiene contexto.

Modifiquemos el código para evitar ese número mágico. 

```c#
const double PRECIO_APLICABLE_DESCUENTO = 1200;
var porcentajeDescuento = 0.05;
var precioDeProducto = 1500d;
var totalAPagar = precioDeProducto;
if(precioDeProducto >= PRECIO_APLICABLE_DESCUENTO)
    totalAPagar -=  (precioDeProducto * porcentajeDescuento);
Console.WriteLine(totalAPagar);
```

Posiblemente vas a tener que crear variables de tipo boolean, es decir que sólo puede ser true o false. En ese caso, puedes usar un truco para verificar si es legible, para ello debes crear una pregunta de la siguiente forma : ¿[nombre de variable]? y la respuesta sólo puede ser Sí/No.

¿No quedó claro? Siguiendo el código de ejemplo anterior, supongamos que creaste una variable boolean llamada *aDescontar* entonces la pregunta que formularias sería *¿A descontar? Sí/No*. Como puedes ver no es muy claro, por lo tanto hay que buscar otro nombre que sea más entendible, por ejemplo, si lo llamamos *aplicaDescuento*, tendríamos la siguiente pregunta *¿Aplica descuento? Sí/No*. Este último es mucho más entendible, por lo tanto ya encontraste el nombre ideal para tu variable.

```c#
const double PRECIO_APLICABLE_DESCUENTO = 1200;
var descuento = 0.05;
var precioDeProducto = 1500d;
var totalAPagar = precioDeProducto;
var aplicaDescuento = precioDeProducto >= PRECIO_APLICABLE_DESCUENTO; // Nuestra variable legible
if(aplicaDescuento)
    totalAPagar -=  (precioDeProducto * descuento);
Console.WriteLine(totalAPagar);
```

### 2. Utilizar nombres en inglés

Aunque no es obligatorio, es recomendable utilizar nombres de variables en inglés, ya que es el idioma que se utiliza comúnmente en la documentación y en la comunidad de desarrollo de software.

Sin embargo, otro motivo por el que recomiendo usar variables en inglés (si es que el proyecto en el que estas te lo permite), es porque crear nombres de variables es mucho más sencillo en este idioma, ya que el español tiene muchas reglas gramaticales que eventualmente tendrás problema con alguna palabra o letras como la ñ.

Por otro lado, los nombres de las clases o métodos que usarás de librerías nativas de la tecnología que estés usando, están en inglés, por lo que terminarás con un proyecto en spanglish.

### 3. Técnicas de Naming para mejorar la legibilidad

Es posible que te encuentres con que una palabra no es suficientemente descriptivo para tu variable, para ello existen las técnicas de Naming, las más populares son: Camel Case, Pascal Case, Snake Case, Kebab Case. En los ejemplos anteriores hemos hecho uso de estas.

| Técnica de Naming | Descripción | Ejemplo |
| --- | --- | --- |
| Camel Case | Escribir palabras juntas sin espacios, cada palabra adicional comienza con mayúscula. | ejemploDeCamelCase |
| Pascal Case | Escribir palabras juntas sin espacios, cada palabra comienza con mayúscula. | EjemploDePascalCase |
| Snake Case | Escribir palabras separadas por guiones bajos. | ejemplo_de_snake_case |


```c#
// Ejemplo de variables escritas en Camel Case
int contadorDeVotos = 0;
string textoDeError = "No se pudo cargar el archivo.";

// Ejemplo de variables escritas en Pascal Case
int Edad = 27;
string NombreCompleto = "Ana Garcia";

// Ejemplo de variables escritas en Snake Case, usando principalmente en Constantes
const double PRECIO_APLICABLE_DESCUENTO = 1200;
const int CODIGO_POR_DEFECTO = 999;
```

## Consejos para trabajar con variables en C#

> Si vas a realizar la misma operación en diferentes partes del mismo método, es mejor **crear una variable local que guarde el resultado de esa operación**. De esta manera, se evita realizar la operación varias veces y se mejora el rendimiento del código. Además, el uso de una variable local puede hacer que el código sea más legible y fácil de entender para otros desarrolladores que puedan trabajar en el mismo proyecto.

> Utiliza tipos de datos adecuados para los valores que vas a almacenar. Por ejemplo, si necesitas almacenar números enteros pequeños como la edad de un usuario, utiliza tipos **byte en lugar de int**. Esto puede ahorrar espacio en memoria y mejorar el rendimiento.

> Usa el modificador **const** para crear constantes, es decir valores que no cambian en tiempo de ejecución. Esto permite al compilador optimizar el código eliminando la necesidad de asignar memoria dinámica para estas variables.

> Utiliza **nombres descriptivos** y en inglés para tus variables que sean fáciles de leer para otros desarrolladores.

> Crea estándares en tus proyectos usando las **técnicas de Naming** para una mejor legibilidad y homogeneidad. De esta forma se mantiene el mismo formato en los nombres de variables en todo el proyecto.

Espero que este post te sea de utilidad y lo hayas disfrutado. 
¡Happy coding!