Constantes y la palabra clave var

1. Constantes

Una constante es una variable "mágica" cuyo valor no se puede (¡ni se debe!) cambiar después de declararla. Imagínate una pegatina superpegajosa en tu taza que dice "Solo té". Si le pones esa pegatina, ya no puedes cambiar el té por café (al menos, en el mundo de C#).

const int DiasEnSemana = 7;
const string MensajeBienvenida = "¡Bienvenido!";

En estos ejemplos, DiasEnSemana siempre será 7, y MensajeBienvenida — siempre será el mensaje de bienvenida. Una vez que defines el valor de una constante, ya no lo puedes cambiar.

¿Para qué sirven las constantes?

• Claridad del código: cuando ves const double Pi = 3.14159;, no hay dudas de que es una constante y no una variable que alguien pueda cambiar en medio del programa.
• Seguridad: nadie (ni siquiera tú dentro de unos meses) podrá sobrescribir el valor de la constante por accidente.
• Rendimiento: el compilador de C# mete el valor de la constante directamente en los sitios donde se usa, así que el programa va un pelín más rápido.

Sintaxis de declaración

const tipo nombre = valor;

• Tipo — cualquier tipo primitivo (int, double, string, char, también enumeraciones y literales).
• Nombre — se suele usar el estilo CamelCase o PascalCase. Para constantes "mágicas" a veces se usan todas mayúsculas y guiones bajos (DIAS_EN_SEMANA), pero en C# no es obligatorio.

Ejemplos:

const double GRAVEDAD = 9.81; // aceleración de la gravedad, m/s^2
const char DELIMITADOR = ',';
const string NOMBRE_DESARROLLADOR = "Ivan Petrov";

Características y limitaciones de las constantes

• El valor debe ser conocido en tiempo de compilación. O sea, no puedes declarar una constante cuyo valor se calcule durante la ejecución del programa.

const int AnoActual = DateTime.Now.Year; // ¡ERROR DE COMPILACIÓN!

• Solo puedes usar tipos simples, string o enumeraciones.
• No puedes hacer constante un array, un objeto, el resultado de un método, etc.
• Incluso expresiones que parecen "simples" matemáticamente, deben ser calculadas por el compilador, no durante la ejecución.

Por ejemplo, esto no se puede:

const string SaludoCompleto = "Hola, " + nombreUsuario; // nombreUsuario es una variable, ¡no se puede!

Pero esto sí — y deberías hacerlo así:

const string SaludoPorDefecto = "Hola, usuario!";

¿Dónde se suelen declarar las constantes?

• Al principio de la clase (o del archivo), encima de los métodos.
• En clases especiales para constantes (por ejemplo, public static class Constantes).
• A nivel de clase, si la constante solo tiene sentido en esa clase.

Ejemplo para nuestra app de consola:

class Program
{
    const string Bienvenida = "¡Bienvenido a nuestra aplicación!";
    static void Main(string[] args)
    {
        Console.WriteLine(Bienvenida);
    }
}

Constantes y ámbito de visibilidad

Las constantes siguen las mismas reglas de ámbito que las variables normales: solo se ven en el rango donde se declaran.

2. La palabra clave var

La palabra clave var — no es un tipo nuevo de variable, sino una forma cómoda de dejar que el compilador deduzca el tipo de la variable por el contexto.

Es puro azúcar sintáctico — aquí no hay magia, y después de compilar la variable se convierte en un tipo normal.

var edad = 23;      // el compilador entiende: edad es int
var nombre = "Anna"; // el compilador entiende: string
var precio = 99.99; // el compilador entiende: double

¿Por qué apareció var?

• Legibilidad: no tienes que escribir tipos largos (como Dictionary<string, List<int>>) a mano.
• Flexibilidad: te permite cambiar tipos más fácilmente en el futuro: si cambias a la derecha, a la izquierda var ya se adapta.
• Estilo moderno: casi todos los proyectos modernos de C# usan var donde el tipo se entiende fácil por la inicialización.

Cuándo puedes (y deberías) usar var

• Cuando a la derecha se ve claramente qué tipo tiene la variable.
• Cuando el tipo es obvio (var precio = 100; — está claro que es int).
• Cuando el tipo es muy largo o complicado (por ejemplo, el resultado de una consulta LINQ).

var numeros = new int[] { 1, 2, 3, 4 };
var entrada = Console.ReadLine(); // entrada es string (el método devuelve string)

Cuándo es mejor NO usar var

Si el tipo no es obvio por la parte derecha, el código puede volverse menos claro. Y si dentro de un mes ni tú ni tus compis sabéis qué tipo era, mejor ponlo explícito.

var misterio = HacerAlgoMuyComplicado(); // ¿QUIÉN ERES, misterio???

Aquí es mejor poner el tipo explícito:

string resultado = HacerAlgoMuyComplicado();

Regla de oro: ¡usa var solo donde no empeora la legibilidad!

var — solo para variables locales

La palabra clave var solo funciona para variables locales — dentro de métodos. No puedes usar var para:

• parámetros de métodos;
• propiedades de clase;
• constantes.

¿Cómo funciona var "por dentro"?

• El compilador de C# mete el tipo correcto durante la compilación.
• Después de compilar, no queda ningún var.
• No hay ninguna pérdida de rendimiento: es solo comodidad para el programador.

var ano = 2025; // en compilación se convierte en: int ano = 2025;

Errores típicos al usar var

• Variable no inicializada:

var a; // ERROR: ¡El compilador no puede deducir el tipo!

• Inicialización ambigua:

var lista = null; // ERROR: ¡El tipo null no está definido!

• Reutilizar la variable con tipos diferentes:

var valor = 5; // valor es int
valor = "Cinco"; // ERROR: ¡valor ya es int!

Comparación: tipos explícitos y var

int edad = 42;

var edad = 42;

Dictionary<int, string> dic = AlgunaFuncion();

var dic = AlgunaFuncion();

string[] nombres = ...

var nombres = ...

3. Trampas y consejos

En C# muchas veces se ponen números mágicos directamente en el código ("7", "3.14159", "0.15" y otros números misteriosos). Eso está mal: si de repente el valor cambia, tendrás que buscar todas las menciones por todo el proyecto. ¡Usa constantes! Así será más fácil para ti y tus compis no te odiarán...

Con var pasa lo contrario: si todo tu código es puro var y nunca se ve qué tipos se usan — el código se vuelve incomprensible muy rápido. Así que usa var donde tenga sentido y sea claro por el contexto, y en los demás casos no dudes en poner el tipo explícito.