Parámetro opcional para controlar impresión en C#

Controla la salida en consola con precisión en C#. Aquí verás cómo añadir un parámetro opcional para decidir si mostrar evaluaciones, ordenar la lógica condicional para evitar errores y personalizar la impresión por tipo de objeto. Además, se deja lista la ruta para refactorizar múltiples if hacia switch de forma más clara.

¿Cómo controlar la impresión de evaluaciones en C#?

Para no inundar la consola, se agrega un parámetro opcional que decide si imprimir evaluaciones. Por defecto es false para reducir ruido. La clave está en el orden de las preguntas: primero se verifica el tipo y luego la intención de imprimir. Así evitamos imprimir por error cuando el flag está en false.

• Usa un parámetro opcional: imprimirEvaluaciones = false.
• Aplica filtrado por tipo antes del flag.
• Imprime todo lo que no sea evaluación sin restricciones.

Ejemplo en C# (patrones de tipo y flujo claro):

data void ImprimirDiccionario(Dictionary<string, IEnumerable<object>> datos, bool imprimirEvaluaciones = false)
{
    foreach (var par in datos)
    {
        foreach (var val in par.Value)
        {
            if (val is Evaluacion eva)
            {
                if (imprimirEvaluaciones)
                    Console.WriteLine(eva.ToString());
            }
            else if (val is Escuela esc)
            {
                Console.WriteLine($"Escuela: {esc}");
            }
            else if (val is Alumno alu)
            {
                // Solo el nombre del alumno.
                Console.WriteLine($"Alumno: {alu.Nombre}");
            }
            else
            {
                Console.WriteLine(val);
            }
        }
    }
}

¿Qué error lógico conviene evitar?

Combinar en una sola condición “quiero imprimir” y “es evaluación” puede llevar a que el bloque else imprima todo lo demás sin control. La forma segura es:

• Primero: if (val es Evaluacion).
• Luego: if (imprimirEvaluaciones) imprimir.
• En caso contrario: imprimir siempre los demás tipos.

¿Cómo validar el resultado y depurar?

La verificación se hace con Visual Studio y la consola.

• Ejecuta con dotnet run para revisar la salida.
• Limpia la consola antes de reintentar si ves datos viejos.
• Usa punto de interrupción y F5 para depurar paso a paso.
• Observa el tipo real en tiempo de ejecución y el valor del flag.

¿Cómo personalizar la salida por tipo con if?

Se decide qué mostrar según el tipo concreto. Cuando es escuela, se imprime su ToString con etiqueta. Para alumno, solo el nombre. Para otros tipos, el valor tal cual. Este patrón organiza la lectura y facilita la depuración.

• Escuela: etiqueta “Escuela:” y su ToString.
• Alumno: solo el nombre.
• Evaluación: respetar el flag imprimirEvaluaciones.
• Otros tipos: impresión por defecto.

Código ilustrativo:

if (val is Evaluacion eva)
{
    if (imprimirEvaluaciones)
        Console.WriteLine(eva.ToString());
}
else if (val is Escuela esc)
{
    Console.WriteLine($"Escuela: {esc}");
}
else if (val is Alumno alu)
{
    Console.WriteLine($"Alumno: {alu.Nombre}");
}
else
{
    Console.WriteLine(val);
}

Puntos clave que se aplican en el flujo:

• Uso de foreach para recorrer colecciones.
• Manejo de condiciones con if y orden correcto de evaluación.
• Llamadas a ToString para salidas legibles.
• Separación de responsabilidades: flag solo afecta a evaluaciones.

¿Cómo preparar la refactorización con switch y gettype?

Cuando crecen los if anidados, es más claro migrar a switch. La idea es conmutar por el tipo del objeto para mantener casos bien separados. La transición propuesta se basa en val.GetType.

• Objetivo: reemplazar múltiples if por switch.
• Entrada del switch: val.GetType().
• Beneficio: casos explícitos por tipo y mantenimiento sencillo.

Borrador de estructura:

switch (val.GetType())
{
    case Type t when t == typeof(Evaluacion):
        if (imprimirEvaluaciones) Console.WriteLine(val.ToString());
        break;
    case Type t when t == typeof(Escuela):
        Console.WriteLine($"Escuela: {val}");
        break;
    case Type t when t == typeof(Alumno):
        // Solo el nombre del alumno.
        var alu = (Alumno)val;
        Console.WriteLine($"Alumno: {alu.Nombre}");
        break;
    default:
        Console.WriteLine(val);
        break;
}

¿Te gustaría ver el refactor completo a switch y comparar ambos enfoques paso a paso? Deja tu comentario con tus dudas o variantes que quieras probar.