Filtrado y Personalización de Impresión en C#

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

En un entorno de desarrollo continuo y en proyectos robustos, gestionar la impresión de datos es un reto crucial. El objetivo es evitar sobrecargar la consola con información excesiva y mantener un flujo de trabajo ordenado. En este contexto, uno de los aspectos clave es decidir cuándo imprimir ciertos tipos de datos, como en el caso de las evaluaciones.

Para abordar este problema, se recomienda utilizar parámetros opcionales en métodos que actúen como interruptores, decidiendo si se imprime o no cierta información. Este enfoque no solo organiza el código, sino que ofrece flexibilidad sobre la cantidad de datos mostrados. A continuación, se describirá, paso a paso, cómo implementar esta funcionalidad en C#.

¿Cómo agregar parámetros opcionales para controlar la impresión?

• Definición del parámetro: Comienza añadiendo un parámetro opcional en el método relevante, por ejemplo, bool imprimirEvaluaciones = false;.
• Filtrado por tipo de objeto: Luego, verifica si el objeto actual es una evaluación: if (imprimirEvaluaciones && val is Evaluacion).
• Información no esencial: Si los datos no son evaluaciones, a menos que se indique lo contrario, no deben imprimirse.

public void ImprimirDatos(IEnumerable<object> objetos, bool imprimirEvaluaciones = false)
{
    foreach (var val in objetos)
    {
        if (val is Evaluacion && imprimirEvaluaciones)
        {
            Console.WriteLine(val.ToString());
        }
        else if (!(val is Evaluacion))
        {
            Console.WriteLine(val.ToString());
        }
    }
}

¿Qué errores pueden surgir y cómo corregirlos?

Al implementar este filtro, pueden surgir algunos errores lógicos que deben ser corregidos. Veamos los más comunes:

• Condiciones incorrectas: A menudo, la lógica puede estructurarse de tal manera que no se impriman otros objetos debido a errores en el diseño de las condiciones if-else.
• Datos residuales en consola: Es posible que se impriman datos de ejecuciones anteriores. Se recomienda limpiar la consola regularmente para evitar confusiones.

Console.Clear(); // Usar antes de cada nueva ejecución

¿Cómo personalizar la impresión para diferentes tipos de objetos?

Un enfoque eficaz es definir tratamientos específicos para tipos de datos variados. Por ejemplo, imprimir solo el nombre para objetos tipo Alumno. Esto se logra dentro del ciclo que itera sobre los objetos.

• Impresión personalizada según tipo de objeto:
  • Si el objeto es una Escuela, imprime todo el contenido.
  • Si es un Alumno, solo el nombre.
  • Aplicar diferentes tratamientos a otros tipos, según la necesidad.

foreach (var val in objetos)
{
    if (val is Evaluacion && imprimirEvaluaciones)
    {
        Console.WriteLine($"Evaluacion: {val.ToString()}");
    }
    else if (val is Escuela)
    {
        Console.WriteLine($"Escuela: {val.ToString()}");
    }
    else if (val is Alumno)
    {
        Console.WriteLine($"Alumno: {((Alumno)val).Nombre}");
    }
    else
    {
        Console.WriteLine(val.ToString());
    }
}

¿Cuándo utilizar 'switch' en lugar de múltiples 'if'?

En situaciones con múltiples condiciones, switch es preferido sobre bloques de if-else debido a su capacidad de optimizar la lectura y mantenimiento del código. Utilizar switch sobre el tipo de objeto garantiza que las acciones específicas se ejecuten de manera más eficaz.

switch (val.GetType().ToString())
{
    case "Evaluacion":
        if (imprimirEvaluaciones)
            Console.WriteLine($"Evaluacion: {val.ToString()}");
        break;
    case "Escuela":
        Console.WriteLine($"Escuela: {val.ToString()}");
        break;
    case "Alumno":
        Console.WriteLine($"Alumno: {((Alumno)val).Nombre}");
        break;
    default:
        Console.WriteLine(val.ToString());
        break;
}

Esta estructura no solo es más legible, sino que mejora significativamente el rendimiento del programa al abordar cada posible tipo de objeto con precisión y claridad.

Al explorar estas estrategias, se proporciona un control más granular sobre el flujo de datos y se fomenta una codificación limpia y funcional en proyectos complejos. Adoptar estas prácticas permitirá a los desarrolladores refinar sus habilidades y aumentar la eficiencia en sus proyectos de C#.