Tipos de datos, variables y constantes

Tipos de datos

En C# cada valor que manipulamos tiene asociado un tipo de datos específico que determina qué operaciones podemos realizar con él y cómo se almacena en memoria. Los tipos de datos actúan como un contrato que especifica el rango de valores permitidos y las operaciones válidas para cada elemento de información.

C# utiliza un sistema de tipos fuertemente tipado, lo que significa que cada variable debe tener un tipo específico declarado en tiempo de compilación. Esta característica nos ayuda a detectar errores antes de que el programa se ejecute y hace que nuestro código sea más predecible y mantenible.

Clasificación básica de tipos

Los tipos en C# se dividen principalmente en dos categorías fundamentales:

• Tipos de valor: Almacenan directamente el dato en la memoria asignada a la variable
• Tipos de referencia: Almacenan una referencia (dirección) hacia donde se encuentra el dato real

Esta distinción es importante porque afecta al comportamiento de asignación y comparación de variables, aunque por ahora nos centraremos en comprender los tipos más utilizados.

Tipos numéricos enteros

Los tipos enteros representan números sin parte decimal y tienen diferentes rangos según el espacio que ocupan en memoria:

int numeroEntero = 42;           // 32 bits, rango: -2,147,483,648 a 2,147,483,647
long numeroGrande = 1234567890L; // 64 bits, rango más amplio
short numeroCorto = 32767;       // 16 bits, rango: -32,768 a 32,767
byte numeroPequeno = 255;        // 8 bits, rango: 0 a 255

El tipo int es el más comúnmente utilizado para números enteros ya que ofrece un buen equilibrio entre rango y eficiencia. Observa cómo para el tipo long añadimos la letra L al final del número para indicar explícitamente que es un literal de tipo long.

Tipos numéricos decimales

Para representar números con parte decimal, C# ofrece varios tipos con diferente precisión y rango:

double precio = 19.99;           // Precisión doble, el más usado para decimales
float descuento = 0.15f;         // Precisión simple, requiere sufijo 'f'
decimal dinero = 1000.50m;       // Alta precisión, ideal para cálculos monetarios

El tipo double es la elección predeterminada para números decimales, mientras que decimal se utiliza cuando necesitamos máxima precisión, especialmente en aplicaciones financieras donde cada centavo cuenta.

Tipo booleano

El tipo bool representa valores de verdad lógica y solo puede contener dos valores posibles:

bool esValido = true;
bool esMenor = false;
bool resultado = 5 > 3;  // El resultado de una comparación es un bool

Los valores booleanos son fundamentales para el control de flujo del programa y las decisiones lógicas que veremos en lecciones posteriores.

Tipo carácter

El tipo char almacena un único carácter Unicode utilizando 16 bits:

char inicial = 'A';
char simbolo = '@';
char espacio = ' ';
char unicode = '\u0041';  // Representación Unicode de 'A'

Los literales de tipo char siempre se escriben entre comillas simples, lo que los distingue de las cadenas de texto que utilizan comillas dobles.

Tipo cadena de texto

El tipo string representa una secuencia de caracteres y es uno de los tipos más utilizados en cualquier aplicación:

string nombre = "María";
string mensaje = "Hola mundo";
string vacio = "";
string nulo = null;  // Una cadena puede ser null

Las cadenas en C# son inmutables, lo que significa que una vez creadas no pueden modificarse. Cualquier operación que parezca modificar una cadena en realidad crea una nueva instancia.

Inferencia de tipos con var

C# permite utilizar la palabra clave var para que el compilador deduzca automáticamente el tipo basándose en el valor asignado:

var numero = 42;           // El compilador infiere que es int
var texto = "Hola";        // El compilador infiere que es string
var decimal = 3.14;        // El compilador infiere que es double
var activo = true;         // El compilador infiere que es bool

El uso de var hace el código más conciso sin perder la seguridad del tipado fuerte, ya que el tipo se determina en tiempo de compilación. Sin embargo, es importante que el tipo sea obvio del contexto para mantener la legibilidad del código.

Valores predeterminados

Cada tipo de datos tiene un valor predeterminado que se asigna automáticamente cuando no se inicializa explícitamente:

int numeroSinInicializar;     // Valor predeterminado: 0
bool banderaSinInicializar;   // Valor predeterminado: false
string textoSinInicializar;   // Valor predeterminado: null

Es una buena práctica inicializar explícitamente las variables para hacer el código más claro y evitar comportamientos inesperados.

Conversiones básicas entre tipos

Aunque profundizaremos en las conversiones más adelante, es útil conocer que C# permite convertir entre tipos compatibles:

int entero = 42;
double decimal = entero;      // Conversión implícita (segura)
int conversion = (int)3.14;   // Conversión explícita (puede perder datos)
string texto = entero.ToString();  // Conversión a texto

Las conversiones implícitas ocurren automáticamente cuando no hay riesgo de pérdida de datos, mientras que las explícitas requieren un cast y pueden resultar en pérdida de información.

Variables y constantes

Una variable en C# es un espacio en memoria que tiene un nombre y puede almacenar un valor que puede cambiar durante la ejecución del programa. Las variables actúan como contenedores etiquetados donde guardamos información que necesitamos utilizar y modificar a lo largo de nuestro código.

Declaración de variables

Para crear una variable en C#, debemos especificar su tipo de datos seguido del nombre que le queremos asignar:

int edad;
string nombre;
double salario;
bool esActivo;

Esta forma de declaración crea la variable pero no le asigna ningún valor inicial, por lo que contendrá el valor predeterminado de su tipo.

Inicialización de variables

Es recomendable inicializar las variables en el momento de su declaración para evitar errores y hacer el código más claro:

int edad = 25;
string nombre = "Ana";
double salario = 2500.50;
bool esActivo = true;

También podemos separar la declaración de la inicialización si el valor se determina más adelante en el código:

int resultado;
// ... código intermedio ...
resultado = edad * 2;

Reglas para nombrar variables

Los nombres de variables en C# deben seguir ciertas reglas obligatorias:

• Comenzar con una letra o guión bajo (_)
• Contener solo letras, números y guiones bajos
• No usar palabras reservadas del lenguaje
• Distinguir entre mayúsculas y minúsculas

// Nombres válidos
int edad;
string _nombre;
double salario2024;
bool esValido;

// Nombres no válidos
// int 2edad;        // No puede empezar con número
// string class;     // 'class' es palabra reservada
// double salario-neto; // No se permite el guión

Convenciones de nomenclatura

Aunque no son obligatorias, las convenciones de nomenclatura hacen que el código sea más legible y profesional:

• camelCase para variables locales: nombreCompleto, edadUsuario
• Nombres descriptivos que expliquen el propósito: contadorVisitas en lugar de c
• Evitar abreviaciones confusas: numeroTelefono en lugar de numTel

// Buenas prácticas
int contadorElementos = 0;
string direccionEmail = "usuario@ejemplo.com";
double precioConImpuestos = 150.75;
bool esMayorDeEdad = edad >= 18;

// Evitar
int x = 0;
string e = "usuario@ejemplo.com";
double p = 150.75;
bool b = edad >= 18;

Ámbito de las variables

El ámbito (scope) de una variable determina dónde puede ser utilizada dentro del código. Las variables locales solo son accesibles dentro del bloque donde se declaran:

public class Ejemplo
{
    // Variable de campo (accesible en toda la clase)
    private int contadorGlobal = 0;
    
    public void MetodoEjemplo()
    {
        // Variable local (solo accesible en este método)
        int contadorLocal = 5;
        
        if (contadorLocal > 0)
        {
            // Variable de bloque (solo accesible dentro del if)
            string mensaje = "Contador positivo";
            Console.WriteLine(mensaje);
        }
        
        // mensaje no es accesible aquí
        Console.WriteLine(contadorLocal); // Esto sí funciona
    }
}

Constantes con const

Las constantes son valores que no pueden cambiar una vez asignados. Se declaran utilizando la palabra clave const y deben inicializarse en el momento de la declaración:

const int DIAS_SEMANA = 7;
const double PI = 3.14159;
const string EMPRESA = "Mi Empresa S.L.";
const bool MODO_DEBUG = true;

Las constantes se evalúan en tiempo de compilación, lo que significa que su valor debe conocerse antes de ejecutar el programa. Por convención, se escriben en MAYÚSCULAS con guiones bajos para separar palabras.

Variables de solo lectura con readonly

Para situaciones donde necesitamos un valor inmutable que se puede calcular en tiempo de ejecución, utilizamos readonly:

public class Configuracion
{
    public readonly DateTime fechaInicio = DateTime.Now;
    public readonly string rutaArchivos;
    
    public Configuracion(string ruta)
    {
        // readonly puede asignarse en el constructor
        rutaArchivos = ruta;
    }
}

La diferencia clave es que readonly permite la asignación en el constructor, mientras que const debe tener su valor definido en la declaración.

Variables locales implícitamente tipadas

Con var podemos crear variables donde el compilador deduce el tipo automáticamente, pero una vez asignado, el tipo no puede cambiar:

var numero = 42;           // int
var texto = "Hola";        // string
var precio = 19.99;        // double
var activo = true;         // bool

// Una vez declarada, la variable mantiene su tipo
numero = 100;              // Válido (int)
// numero = "texto";       // Error: no se puede cambiar el tipo

Declaración múltiple de variables

C# permite declarar múltiples variables del mismo tipo en una sola línea:

int x, y, z;                    // Tres variables sin inicializar
int a = 1, b = 2, c = 3;        // Tres variables inicializadas
string nombre, apellido, email;  // Múltiples strings

Aunque esta sintaxis es válida, es preferible declarar una variable por línea para mejorar la legibilidad del código.

Inicialización tardía con valores calculados

En ocasiones necesitamos calcular el valor de una variable basándose en otros datos:

int baseImponible = 1000;
double tipoIVA = 0.21;

// La variable se inicializa con un cálculo
double iva = baseImponible * tipoIVA;
double precioFinal = baseImponible + iva;

Console.WriteLine($"Precio final: {precioFinal:C}");

Buenas prácticas con variables y constantes

Para escribir código mantenible y profesional, sigue estas recomendaciones:

• Inicializa las variables cerca de donde las vas a usar
• Utiliza nombres descriptivos que expliquen el propósito
• Prefiere const para valores que nunca cambian
• Usa readonly para valores que se calculan una sola vez
• Limita el ámbito de las variables al mínimo necesario
• Evita variables con nombres similares que puedan confundir

// Ejemplo de buenas prácticas
public class GestorPedidos
{
    private const double DESCUENTO_VIP = 0.15;
    private readonly DateTime fechaCreacion = DateTime.Now;
    
    public double CalcularTotal(double subtotal, bool esClienteVip)
    {
        double descuentoAplicado = esClienteVip ? DESCUENTO_VIP : 0.0;
        double totalConDescuento = subtotal * (1 - descuentoAplicado);
        
        return totalConDescuento;
    }
}

Este enfoque hace que el código sea más legible, mantenible y menos propenso a errores, características fundamentales en el desarrollo profesional.