Const vs variable en C# cuándo usar cada una

Contenido del curso

Fundamentos

Tipos de Datos y Variables

Control de Flujo

Programación Orientada a Objetos

Interfaces y Arquitectura

Herramientas y Entorno de Desarrollo

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:002:18

Const vs variable en C# cuándo usar cada una

Curso de Introducción a .NET con C#

Clase 7 de 25

Clase 7 / 25

Recursos

Si trabajas con C# en .NET, entender la diferencia entre valores constantes y valores variables es lo que evita que tu aplicación se rompa por un dato modificado donde no debía. Esta guía te muestra cómo declararlos en Visual Studio Code, qué errores aparecen al equivocarte y en qué escenarios reales conviene usar cada uno.

¿Qué pasa cuando cambias una variable a constante en C#?

Al reemplazar la palabra variable por const en tu declaración, Visual Studio Code te marca un error inmediato. La razón es directa: las constantes necesitan ser tipadas desde su origen, mientras que las variables pueden inferir el tipo.

Para que el error desaparezca, debes anteponer el tipo de dato. Si tu constante guarda un nombre, la declaración correcta lleva string adelante. Una vez tipada, el valor queda inalterable e inmutable dentro de toda la aplicación.

¿Qué es una constante en C#? Es un valor que se asigna una sola vez al declararlo y no puede modificarse en ningún punto de la aplicación. Requiere que indiques su tipo de dato explícitamente.

¿Por qué aparece un error rojo al reasignar una constante?

Si intentas algo como nombre = "Felipe" después de haber declarado nombre como const, ni siquiera necesitas compilar para ver el problema. El editor te subraya en rojo la línea y te avisa que estás intentando asignar un nuevo dato a una constante.

Este comportamiento es una de las protecciones que .NET ofrece en tiempo de edición. Detectas el error antes de ejecutar el código, lo que ahorra horas de depuración en proyectos grandes.

¿Cuándo usar valores constantes en .NET?

Las constantes brillan en escenarios donde un dato debe permanecer fijo a lo largo de toda la vida de la aplicación. Aquí los casos más claros:

Cadenas de conexión a bases de datos que se reutilizan en varios módulos.
Secretos y claves de configuración que no deben sobrescribirse por accidente.
Estructuras compartidas entre módulos donde una modificación rompería la lógica.

Usar const en estos casos te blinda contra el escenario más temido: que algún módulo, sin querer, reasigne la cadena de conexión y tu aplicación deje de hablar con la base de datos.

¿Cuándo conviene usar const en lugar de una variable? Cuando el valor debe ser el mismo en toda la aplicación y no debe poder modificarse, como cadenas de conexión, secretos o configuraciones globales.

¿Cuándo conviene usar valores variables?

Las variables son tu herramienta natural para datos que cambian durante la ejecución. Si declaras apellido como variable y luego lo reasignas a Espinosa de los Monteros, no obtienes ningún error porque esa es justamente su naturaleza: aceptar nuevos valores.

Cada reasignación entrega un dato actualizado sin alterar el comportamiento global de la aplicación. Las usas cuando quieras y como quieras dentro del ciclo de vida del programa.

¿Qué diferencia práctica hay entre const y variable?

La distinción se reduce a intención y seguridad:

const: declaras una vez, tipas el valor desde el origen, y queda bloqueado.
variable: declaras, y puedes reasignar tantas veces como tu lógica lo requiera.

Dominar esta decisión es una de las mejores técnicas que vas a encontrar en .NET. Tus cadenas de conexión y secretos permanecen intactos, y tus variables siguen siendo flexibles donde lo necesitas.

Conceptos y habilidades clave de la clase

Para cerrar con claridad, estos son los puntos técnicos que aparecen en la práctica y conviene tener siempre presentes.

Constante (const): valor inmutable que requiere tipo explícito al declararse [0:05].
Tipado obligatorio: las constantes en C# necesitan string, int u otro tipo desde su origen [0:15].
Error en tiempo de edición: Visual Studio Code marca en rojo cualquier intento de reasignar una constante [0:30].
Inmutabilidad: una vez asignada, la constante no acepta nuevos valores en ningún módulo [0:25].
Casos de uso de const: cadenas de conexión, secretos y estructuras compartidas entre módulos [0:50].
Reasignación de variables: las variables aceptan nuevos valores sin generar errores [1:15].
Ciclo de vida de la aplicación: las variables pueden cambiar libremente durante la ejecución [1:40].

¿En qué parte de tu proyecto actual identificas un valor que debería ser constante y hoy está como variable? Cuéntalo en los comentarios.

Resumen

¿Qué pasa cuando cambias una variable a constante en C#?

¿Qué es una constante en C#? Es un valor que se asigna una sola vez al declararlo y no puede modificarse en ningún punto de la aplicación. Requiere que indiques su tipo de dato explícitamente.

¿Por qué aparece un error rojo al reasignar una constante?

Este comportamiento es una de las protecciones que .NET ofrece en tiempo de edición. Detectas el error antes de ejecutar el código, lo que ahorra horas de depuración en proyectos grandes.

¿Cuándo usar valores constantes en .NET?

Las constantes brillan en escenarios donde un dato debe permanecer fijo a lo largo de toda la vida de la aplicación. Aquí los casos más claros:

Cadenas de conexión a bases de datos que se reutilizan en varios módulos.
Secretos y claves de configuración que no deben sobrescribirse por accidente.
Estructuras compartidas entre módulos donde una modificación rompería la lógica.

Usar const en estos casos te blinda contra el escenario más temido: que algún módulo, sin querer, reasigne la cadena de conexión y tu aplicación deje de hablar con la base de datos.

¿Cuándo conviene usar const en lugar de una variable? Cuando el valor debe ser el mismo en toda la aplicación y no debe poder modificarse, como cadenas de conexión, secretos o configuraciones globales.

¿Cuándo conviene usar valores variables?

Cada reasignación entrega un dato actualizado sin alterar el comportamiento global de la aplicación. Las usas cuando quieras y como quieras dentro del ciclo de vida del programa.

¿Qué diferencia práctica hay entre const y variable?

La distinción se reduce a intención y seguridad:

const: declaras una vez, tipas el valor desde el origen, y queda bloqueado.
variable: declaras, y puedes reasignar tantas veces como tu lógica lo requiera.

Conceptos y habilidades clave de la clase

Para cerrar con claridad, estos son los puntos técnicos que aparecen en la práctica y conviene tener siempre presentes.

Constante (const): valor inmutable que requiere tipo explícito al declararse [0:05].
Tipado obligatorio: las constantes en C# necesitan string, int u otro tipo desde su origen [0:15].
Error en tiempo de edición: Visual Studio Code marca en rojo cualquier intento de reasignar una constante [0:30].
Inmutabilidad: una vez asignada, la constante no acepta nuevos valores en ningún módulo [0:25].
Casos de uso de const: cadenas de conexión, secretos y estructuras compartidas entre módulos [0:50].
Reasignación de variables: las variables aceptan nuevos valores sin generar errores [1:15].
Ciclo de vida de la aplicación: las variables pueden cambiar libremente durante la ejecución [1:40].

¿En qué parte de tu proyecto actual identificas un valor que debería ser constante y hoy está como variable? Cuéntalo en los comentarios.

// ============================================================================
// VARIABLES Y TIPOS DE DATOS PRIMITIVOS EN C#
// ============================================================================

Console.WriteLine("=== TIPOS DE DATOS PRIMITIVOS EN C# ===\n");

// 1. TIPOS NUMERICOS ENTEROS
Console.WriteLine("1. TIPOS NUMERICOS ENTEROS:");
byte edad = 30;                    // 8 bits (0-255)
short anio = 2025;                 // 16 bits (-32,768 a 32,767)
int poblacion = 1000000;           // 32 bits (-2,147,483,648 a 2,147,483,647)
long habitantes = 7800000000L;     // 64 bits (muy grandes)

Console.WriteLine($"   byte edad = {edad} (rango: 0 a 255)");
Console.WriteLine($"   short anio = {anio} (rango: -32,768 a 32,767)");
Console.WriteLine($"   int poblacion = {poblacion:N0}");
Console.WriteLine($"   long habitantes = {habitantes:N0}");

// 2. TIPOS NUMERICOS DECIMALES
Console.WriteLine("\n2. TIPOS NUMERICOS DECIMALES:");
float temperatura = 36.5f;         // 32 bits, precisión ~7 dígitos
double altura = 1.75;              // 64 bits, precisión ~15-17 dígitos
decimal precio = 29.99m;           // 128 bits, precisión ~28-29 dígitos (ideal para dinero)

Console.WriteLine($"   float temperatura = {temperatura}°C (precisión: ~7 dígitos)");
Console.WriteLine($"   double altura = {altura}m (precisión: ~15-17 dígitos)");
Console.WriteLine($"   decimal precio = ${precio} (precisión: ~28-29 dígitos)");

// 3. TIPOS DE CARACTERES Y TEXTO
Console.WriteLine("\n3. TIPOS DE CARACTERES Y TEXTO:");
char inicial = 'A';                // Un solo carácter Unicode
string nombre = "Alex";            // Cadena de caracteres
string apellido = "Vera";

Console.WriteLine($"   char inicial = '{inicial}' (un solo carácter)");
Console.WriteLine($"   string nombre = \"{nombre}\" (cadena de caracteres)");
Console.WriteLine($"   string apellido = \"{apellido}\"");

// 4. TIPO BOOLEANO
Console.WriteLine("\n4. TIPO BOOLEANO:");
bool esEstudiante = true;          // true o false
bool esMayorDeEdad = edad >= 18;

Console.WriteLine($"   bool esEstudiante = {esEstudiante}");
Console.WriteLine($"   bool esMayorDeEdad = {esMayorDeEdad} (calculado: {edad} >= 18)");

// 5. INFERENCIA DE TIPOS CON 'var'
Console.WriteLine("\n5. INFERENCIA DE TIPOS CON 'var':");
var peso = 70.5;                   // El compilador infiere que es double
var activo = true;                 // El compilador infiere que es bool
var codigo = 12345;                // El compilador infiere que es int

Console.WriteLine($"   var peso = {peso} (inferido como: {peso.GetType().Name})");
Console.WriteLine($"   var activo = {activo} (inferido como: {activo.GetType().Name})");
Console.WriteLine($"   var codigo = {codigo} (inferido como: {codigo.GetType().Name})");

// ============================================================================
// CONSTANTES VS VARIABLES
// ============================================================================

Console.WriteLine("\n\n=== CONSTANTES VS VARIABLES ===\n");

// CONSTANTES: Valores que NO pueden cambiar durante la ejecución
Console.WriteLine("CONSTANTES (valores inmutables):");
const double PI = 3.14159;         // Constante matemática
const int DIAS_SEMANA = 7;         // Constante de configuración
const string EMPRESA = "Mi Empresa S.A."; // Constante de texto
const bool ES_VERSION_DEBUG = true; // Constante de configuración

Console.WriteLine($"   const double PI = {PI}");
Console.WriteLine($"   const int DIAS_SEMANA = {DIAS_SEMANA}");
Console.WriteLine($"   const string EMPRESA = \"{EMPRESA}\"");
Console.WriteLine($"   const bool ES_VERSION_DEBUG = {ES_VERSION_DEBUG}");

// Intentar cambiar una constante causaría un error de compilación:
// PI = 3.14; // ❌ ERROR: No se puede asignar a una constante

// VARIABLES: Valores que SÍ pueden cambiar durante la ejecución
Console.WriteLine("\nVARIABLES (valores mutables):");
string nombreUsuario = "Alex";     // Puede cambiar
int intentos = 0;                  // Puede cambiar
double saldo = 1000.50;            // Puede cambiar

Console.WriteLine($"   Valores iniciales:");
Console.WriteLine($"   string nombreUsuario = \"{nombreUsuario}\"");
Console.WriteLine($"   int intentos = {intentos}");
Console.WriteLine($"   double saldo = ${saldo}");

// Modificando las variables
nombreUsuario = "Alex Vera";       // ✅ Válido: las variables pueden cambiar
intentos++;                        // ✅ Válido: incrementar
saldo -= 50.25;                    // ✅ Válido: restar del saldo

Console.WriteLine($"\n   Después de modificaciones:");
Console.WriteLine($"   nombreUsuario = \"{nombreUsuario}\" (cambió)");
Console.WriteLine($"   intentos = {intentos} (incrementó)");
Console.WriteLine($"   saldo = ${saldo} (decrementó)");

// ============================================================================
// CUÁNDO USAR CADA UNA
// ============================================================================

Console.WriteLine("\n\n=== CUÁNDO USAR CONSTANTES VS VARIABLES ===\n");

Console.WriteLine("USA CONSTANTES cuando:");
Console.WriteLine("  • El valor NUNCA cambiará (PI, días de la semana)");
Console.WriteLine("  • Configuraciones fijas del sistema");
Console.WriteLine("  • Valores que definen límites o reglas de negocio");
Console.WriteLine("  • Mejora la legibilidad y mantención del código");

Console.WriteLine("\nUSA VARIABLES cuando:");
Console.WriteLine("  • El valor puede cambiar durante la ejecución");
Console.WriteLine("  • Almacenas datos ingresados por el usuario");
Console.WriteLine("  • Realizas cálculos que pueden variar");
Console.WriteLine("  • Necesitas flexibilidad en tu programa");

// ============================================================================
// EJEMPLOS PRÁCTICOS
// ============================================================================

Console.WriteLine("\n\n=== EJEMPLOS PRÁCTICOS ===\n");

// Ejemplo 1: Calculadora de área de círculo
Console.WriteLine("Ejemplo 1: Calculadora de área de círculo");
const double PI_EXACTO = 3.14159265359; // Constante: nunca cambia
double radio = 5.0;                      // Variable: puede cambiar
double area = PI_EXACTO * radio * radio; // Cálculo usando constante y variable

Console.WriteLine($"   Radio: {radio} metros");
Console.WriteLine($"   Área: {area:F2} metros cuadrados");

// Cambiar el radio (la variable)
radio = 10.0;
area = PI_EXACTO * radio * radio;
Console.WriteLine($"   Nuevo radio: {radio} metros");
Console.WriteLine($"   Nueva área: {area:F2} metros cuadrados");

// Ejemplo 2: Sistema de calificaciones
Console.WriteLine("\nEjemplo 2: Sistema de calificaciones");
const double NOTA_MAXIMA = 10.0;        // Constante: la nota máxima no cambia
const double NOTA_APROBACION = 6.0;     // Constante: la nota mínima para aprobar
double notaEstudiante = 8.5;            // Variable: cada estudiante tiene diferente nota

Console.WriteLine($"   Nota máxima posible: {NOTA_MAXIMA}");
Console.WriteLine($"   Nota mínima para aprobar: {NOTA_APROBACION}");
Console.WriteLine($"   Nota del estudiante: {notaEstudiante}");
Console.WriteLine($"   ¿Aprobó?: {(notaEstudiante >= NOTA_APROBACION ? "Sí" : "No")}");

Console.WriteLine("\n=== FIN DEL PROGRAMA ===");

// ============================================================================
// VARIABLES Y TIPOS DE DATOS PRIMITIVOS EN C#
// ============================================================================

Console.WriteLine("=== TIPOS DE DATOS PRIMITIVOS EN C# ===\n");

// 1. TIPOS NUMERICOS ENTEROS
Console.WriteLine("1. TIPOS NUMERICOS ENTEROS:");
byte edad = 30;                    // 8 bits (0-255)
short anio = 2025;                 // 16 bits (-32,768 a 32,767)
int poblacion = 1000000;           // 32 bits (-2,147,483,648 a 2,147,483,647)
long habitantes = 7800000000L;     // 64 bits (muy grandes)

Console.WriteLine($"   byte edad = {edad} (rango: 0 a 255)");
Console.WriteLine($"   short anio = {anio} (rango: -32,768 a 32,767)");
Console.WriteLine($"   int poblacion = {poblacion:N0}");
Console.WriteLine($"   long habitantes = {habitantes:N0}");

// 2. TIPOS NUMERICOS DECIMALES
Console.WriteLine("\n2. TIPOS NUMERICOS DECIMALES:");
float temperatura = 36.5f;         // 32 bits, precisión ~7 dígitos
double altura = 1.75;              // 64 bits, precisión ~15-17 dígitos
decimal precio = 29.99m;           // 128 bits, precisión ~28-29 dígitos (ideal para dinero)

Console.WriteLine($"   float temperatura = {temperatura}°C (precisión: ~7 dígitos)");
Console.WriteLine($"   double altura = {altura}m (precisión: ~15-17 dígitos)");
Console.WriteLine($"   decimal precio = ${precio} (precisión: ~28-29 dígitos)");

// 3. TIPOS DE CARACTERES Y TEXTO
Console.WriteLine("\n3. TIPOS DE CARACTERES Y TEXTO:");
char inicial = 'A';                // Un solo carácter Unicode
string nombre = "Alex";            // Cadena de caracteres
string apellido = "Vera";

Console.WriteLine($"   char inicial = '{inicial}' (un solo carácter)");
Console.WriteLine($"   string nombre = \"{nombre}\" (cadena de caracteres)");
Console.WriteLine($"   string apellido = \"{apellido}\"");

// 4. TIPO BOOLEANO
Console.WriteLine("\n4. TIPO BOOLEANO:");
bool esEstudiante = true;          // true o false
bool esMayorDeEdad = edad >= 18;

Console.WriteLine($"   bool esEstudiante = {esEstudiante}");
Console.WriteLine($"   bool esMayorDeEdad = {esMayorDeEdad} (calculado: {edad} >= 18)");

// 5. INFERENCIA DE TIPOS CON 'var'
Console.WriteLine("\n5. INFERENCIA DE TIPOS CON 'var':");
var peso = 70.5;                   // El compilador infiere que es double
var activo = true;                 // El compilador infiere que es bool
var codigo = 12345;                // El compilador infiere que es int

Console.WriteLine($"   var peso = {peso} (inferido como: {peso.GetType().Name})");
Console.WriteLine($"   var activo = {activo} (inferido como: {activo.GetType().Name})");
Console.WriteLine($"   var codigo = {codigo} (inferido como: {codigo.GetType().Name})");

// ============================================================================
// CONSTANTES VS VARIABLES
// ============================================================================

Console.WriteLine("\n\n=== CONSTANTES VS VARIABLES ===\n");

// CONSTANTES: Valores que NO pueden cambiar durante la ejecución
Console.WriteLine("CONSTANTES (valores inmutables):");
const double PI = 3.14159;         // Constante matemática
const int DIAS_SEMANA = 7;         // Constante de configuración
const string EMPRESA = "Mi Empresa S.A."; // Constante de texto
const bool ES_VERSION_DEBUG = true; // Constante de configuración

Console.WriteLine($"   const double PI = {PI}");
Console.WriteLine($"   const int DIAS_SEMANA = {DIAS_SEMANA}");
Console.WriteLine($"   const string EMPRESA = \"{EMPRESA}\"");
Console.WriteLine($"   const bool ES_VERSION_DEBUG = {ES_VERSION_DEBUG}");

// Intentar cambiar una constante causaría un error de compilación:
// PI = 3.14; // ❌ ERROR: No se puede asignar a una constante

// VARIABLES: Valores que SÍ pueden cambiar durante la ejecución
Console.WriteLine("\nVARIABLES (valores mutables):");
string nombreUsuario = "Alex";     // Puede cambiar
int intentos = 0;                  // Puede cambiar
double saldo = 1000.50;            // Puede cambiar

Console.WriteLine($"   Valores iniciales:");
Console.WriteLine($"   string nombreUsuario = \"{nombreUsuario}\"");
Console.WriteLine($"   int intentos = {intentos}");
Console.WriteLine($"   double saldo = ${saldo}");

// Modificando las variables
nombreUsuario = "Alex Vera";       // ✅ Válido: las variables pueden cambiar
intentos++;                        // ✅ Válido: incrementar
saldo -= 50.25;                    // ✅ Válido: restar del saldo

Console.WriteLine($"\n   Después de modificaciones:");
Console.WriteLine($"   nombreUsuario = \"{nombreUsuario}\" (cambió)");
Console.WriteLine($"   intentos = {intentos} (incrementó)");
Console.WriteLine($"   saldo = ${saldo} (decrementó)");

// ============================================================================
// CUÁNDO USAR CADA UNA
// ============================================================================

Console.WriteLine("\n\n=== CUÁNDO USAR CONSTANTES VS VARIABLES ===\n");

Console.WriteLine("USA CONSTANTES cuando:");
Console.WriteLine("  • El valor NUNCA cambiará (PI, días de la semana)");
Console.WriteLine("  • Configuraciones fijas del sistema");
Console.WriteLine("  • Valores que definen límites o reglas de negocio");
Console.WriteLine("  • Mejora la legibilidad y mantención del código");

Console.WriteLine("\nUSA VARIABLES cuando:");
Console.WriteLine("  • El valor puede cambiar durante la ejecución");
Console.WriteLine("  • Almacenas datos ingresados por el usuario");
Console.WriteLine("  • Realizas cálculos que pueden variar");
Console.WriteLine("  • Necesitas flexibilidad en tu programa");

// ============================================================================
// EJEMPLOS PRÁCTICOS
// ============================================================================

Console.WriteLine("\n\n=== EJEMPLOS PRÁCTICOS ===\n");

// Ejemplo 1: Calculadora de área de círculo
Console.WriteLine("Ejemplo 1: Calculadora de área de círculo");
const double PI_EXACTO = 3.14159265359; // Constante: nunca cambia
double radio = 5.0;                      // Variable: puede cambiar
double area = PI_EXACTO * radio * radio; // Cálculo usando constante y variable

Console.WriteLine($"   Radio: {radio} metros");
Console.WriteLine($"   Área: {area:F2} metros cuadrados");

// Cambiar el radio (la variable)
radio = 10.0;
area = PI_EXACTO * radio * radio;
Console.WriteLine($"   Nuevo radio: {radio} metros");
Console.WriteLine($"   Nueva área: {area:F2} metros cuadrados");

// Ejemplo 2: Sistema de calificaciones
Console.WriteLine("\nEjemplo 2: Sistema de calificaciones");
const double NOTA_MAXIMA = 10.0;        // Constante: la nota máxima no cambia
const double NOTA_APROBACION = 6.0;     // Constante: la nota mínima para aprobar
double notaEstudiante = 8.5;            // Variable: cada estudiante tiene diferente nota

Console.WriteLine($"   Nota máxima posible: {NOTA_MAXIMA}");
Console.WriteLine($"   Nota mínima para aprobar: {NOTA_APROBACION}");
Console.WriteLine($"   Nota del estudiante: {notaEstudiante}");
Console.WriteLine($"   ¿Aprobó?: {(notaEstudiante >= NOTA_APROBACION ? "Sí" : "No")}");

Console.WriteLine("\n=== FIN DEL PROGRAMA ===");

Fundamentos

Por qué C# sigue dominando el desarrollo

C# vs .NET: no son lo mismo

Instalación de .NET 8 en Ubuntu con WSL

Crea y ejecuta tu primer proyecto .NET

Depurar .NET con F5 en VS Code

Tipos de Datos y Variables

Variables primitivas en C# con var y tipos

Const vs variable en C# cuándo usar cada una

Leer y escribir datos en consola con C#

Control de Flujo

Sentencia if y operadores lógicos en C#

for y while en C# sin errores

Ciclo foreach en C# para iterar caracteres y cadenas

Diferencia entre arreglos y listas en C#

Sentencia switch en C# con arreglos y listas

Métodos en C# con void y return

Programación Orientada a Objetos

Clases y namespaces en C# con Calculator

Métodos públicos y privados en clases de C#

Clases estáticas en C# sin instanciar objetos

Interfaces y Arquitectura

Qué son las interfaces en C#

Interfaces en C# con un proyecto Logger

Configuración de depuración en Visual Studio Code para múltiples proyectos

Herramientas y Entorno de Desarrollo

Visual Studio vs VS Code para .NET

Creación de archivos SLN en .NET con múltiples proyectos

Instalación y uso de paquetes NuGet en proyectos .NET

dotnet publish para ejecutables sin SDK

Comandos esenciales de la terminal de .NET

Const vs variable en C# cuándo usar cada una