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.

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:

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.

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;.

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 :

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.

// 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 :

Operadores Lógicos :

Operadores de comparación :

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.

// 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.

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.

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.

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);

1. 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.

// 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!