Constructores con parámetros opcionales en C#

Aprende a escribir código más claro y flexible en C#: constructores con parámetros opcionales, sobrecarga, asignación de tuplas, argumentos con nombre y manejo seguro de cadenas. Además, refuerza conceptos como enumeraciones, propiedades, firma de métodos, concatenación e interpolación de texto. Todo con ejemplos directos y listos para usar en consola.

¿Cómo crear y sobrecargar constructores con parámetros opcionales en C#?

La idea clave: puedes definir varios constructores en una clase y agregar parámetros opcionales con valores por defecto. Así, el objeto se puede construir de distintas formas según lo necesites. Esto mejora la legibilidad y reduce errores.

• Un constructor básico pide lo mínimo: nombre y año.
• Un segundo constructor agrega un parámetro requerido: tipo de escuela (una enumeración).
• Además, define parámetros opcionales: país y ciudad con valor por defecto vacío.
• Las listas de parámetros se separan con coma. El punto y coma cierra instrucciones.

public enum TipoEscuela { Preescolar, Primaria, Secundaria }

public class Escuela
{
    public string Nombre { get; set; }
    public int Año { get; set; }
    public TipoEscuela Tipo { get; set; }
    public string País { get; set; } = "";
    public string Ciudad { get; set; } = "";

    // Constructor 1: mínimo requerido.
    public Escuela(string nombre, int año)
    {
        // Asignación de tuplas: compacto y claro.
        (Nombre, Año) = (nombre, año);
    }

    // Constructor 2: con parámetro requerido 'tipo' y opcionales 'país' y 'ciudad'.
    public Escuela(string nombre, int año, TipoEscuela tipo, string país = "", string ciudad = "")
    {
        (Nombre, Año, Tipo) = (nombre, año, tipo);
        País = país;              // Asignación directa.
        this.Ciudad = ciudad;     // Uso de 'this' para diferenciar campo y parámetro.
    }

    // Opcional: personalizar salida en consola.
    public override string ToString() => $"{Nombre} ({Tipo})";
}

• Con argumentos con nombre, puedes enviar solo los opcionales que quieras y en cualquier orden.

int año = default;
var esc1 = new Escuela("La Silla Cadh-Cademy", año, TipoEscuela.Primaria, país: "Colombia", ciudad: "Bogotá");
var esc2 = new Escuela("La Silla Cadh-Cademy", año, TipoEscuela.Primaria, ciudad: "Bogotá"); // omite 'país'.

¿Por qué la firma permite múltiples versiones?

La firma de un método define: tipo de retorno, nombre y parámetros. Puedes sobrecargar métodos y constructores con el mismo nombre siempre que sus parámetros sean diferentes. Así eliges la versión más conveniente según el caso.

¿Cómo se separan listas y sentencias?

• Punto y coma: final de una instrucción.
• Coma: separa elementos dentro de una lista, por ejemplo, en parámetros.
• Puedes dividir parámetros en varias líneas sin problema si no cierras la instrucción con punto y coma.

¿Cómo manejar cadenas, comillas y saltos de línea en consola?

Al imprimir texto, a veces necesitas incluir comillas dentro de la cadena o controlar la nueva línea correctamente.

• Para dibujar comillas dentro de la cadena: usa la secuencia de escape \".
• Para un salto de línea portátil: prefiere System.Environment.NewLine en lugar de "\n". Diferentes sistemas operativos manejan la nueva línea distinto; con Environment.NewLine obtienes el equivalente correcto dentro del framework.

var nombre = "La Silla Cadh-Cademy";
Console.WriteLine($"El nombre es \"{nombre}\".");

// Concatenación vs. interpolación.
var msg1 = "Hola, " + nombre;            // concatenación con +
var msg2 = $"Hola, {nombre}";             // interpolación con $

// Nueva línea segura entre sistemas.
Console.WriteLine("Primera línea." + System.Environment.NewLine + "Segunda línea.");

• También puedes sobreescribir ToString() para definir cómo se muestra un objeto al imprimirlo.
• La interpolación de cadenas ($"...{var}...") facilita el formateo y disminuye errores frente a la concatenación.

¿Qué conceptos y habilidades consolidaste en C# para consola?

Este bloque refuerza prácticas esenciales para escribir código robusto y legible.

• Inicialización de objetos con la palabra clave new.
• Propiedades: autoimplementadas y uso de this para evitar sombras de nombres.
• Enumeraciones: mejoran legibilidad y reducen errores.
• Constructores: múltiples sobrecargas con parámetros requeridos y opcionales.
• Parámetros opcionales: valores por defecto que vuelven flexible la API.
• Argumentos con nombre: puedes omitir y reordenar opcionales con claridad.
• Firma de métodos: retorno, nombre y parámetros determinan la sobrecarga válida.
• Asignación de tuplas: asigna varios valores en una sola línea.
• Tipos de datos: string y entero en escenarios de consola.
• Espacios de nombres: uso de System y Environment del framework.
• Separadores: punto y coma para sentencias, coma para listas.
• Cadenas: concatenación con + e interpolación con $.
• Escape de caracteres: \" para comillas, System.Environment.NewLine para newline.

¿Tienes dudas o quieres compartir cómo aplicarías estos constructores y parámetros opcionales en tu proyecto? ¡Comenta y conversemos sobre tu caso!