Manejo de errores

Parte de la sección Lógica y Flujo del Journey de C# de Coddy. Lección 45 de 66.

Desafío

Fácil

Mejoremos nuestro sistema con un manejo sólido de errores para abordar los posibles problemas de forma adecuada. Crea una clase llamada ErrorHandler con estos métodos:

ValidateInput(int[][] scoreGrid, int studentIndex, int assignmentIndex): valida los índices de entrada y devuelve un mensaje de error apropiado o una cadena vacía si son válidos.
- Devuelve "Invalid student index" si el índice del estudiante está fuera de los límites.
- Devuelve "Invalid assignment index" si el índice de la tarea está fuera de los límites.
- Devuelve una cadena vacía "" si ambos índices son válidos.
SafeGetScore(int[][] scoreGrid, int studentIndex, int assignmentIndex): recupera una puntuación de forma segura con manejo de errores.
- Devuelve la puntuación si ambos índices son válidos.
- Devuelve -999 si algún índice no es válido.
ProcessBatchUpdate(int[][] scoreGrid, int[][] updates): procesa actualizaciones por lotes, donde cada actualización es [studentIndex, assignmentIndex, score].
- Devuelve un arreglo string[] de mensajes de error para cada actualización fallida.
- Cada actualización puede fallar con uno de estos mensajes de error específicos:
  - "Invalid update format", si la actualización no contiene exactamente 3 valores.
  - "Invalid student index": si el índice del estudiante está fuera de los límites.
  - "Invalid assignment index": si el índice de la tarea está fuera de los límites.
  - "Invalid score value": si la puntuación está fuera del rango válido (0-100).
- Da formato a cada error así: "Error at index X: [specific error message]"
- Devuelve un arreglo vacío si todas las actualizaciones se realizan correctamente.

Sugerencia: Para recopilar errores dinámicamente antes de devolverlos como un string[], usa List<string> errors = new List<string>();. List<string> funciona como un arreglo redimensionable al que puedes llamar errors.Add(...) para agregar elementos. Al final, conviértelo con errors.ToArray(). La importación using System.Collections.Generic; necesaria para esto ya está incluida al principio del archivo.

Pruébalo tú mismo

using System; // No elimines esta línea
using System.Collections.Generic;

public class ErrorHandler
{
    public static string ValidateInput(int[][] scoreGrid, int studentIndex, int assignmentIndex)
    {
        // Escribe tu código aquí
        
    }
    
    public static int SafeGetScore(int[][] scoreGrid, int studentIndex, int assignmentIndex)
    {
        // Escribe tu código aquí
        
    }
    
    public static string[] ProcessBatchUpdate(int[][] scoreGrid, int[][] updates)
    {
        // Escribe tu código aquí
        
    }
}

// Requerido para las pruebas - no modificar
public class DataCollector
{
    public static int[][] CreateScoreGrid(int students, int assignments)
    {
        int[][] scoreGrid = new int[students][];
        for (int i = 0; i < students; i++)
        {
            scoreGrid[i] = new int[assignments];
        }
        return scoreGrid;
    }
    
    public static bool ValidateScore(int score)
    {
        return score >= 0 && score <= 100;
    }
    
    public static int[][] PopulateWithDefaultValues(int[][] scoreGrid)
    {
        for (int i = 0; i < scoreGrid.Length; i++)
        {
            for (int j = 0; j < scoreGrid[i].Length; j++)
            {
                scoreGrid[i][j] = -1;
            }
        }
        return scoreGrid;
    }
}

public class DataEntry
{
    public static int SetStudentScore(int[][] scoreGrid, int studentIndex, int assignmentIndex, int score)
    {
        // Comprueba si los índices están fuera de los límites
        if (studentIndex < 0 || studentIndex >= scoreGrid.Length || 
            assignmentIndex < 0 || assignmentIndex >= scoreGrid[studentIndex].Length)
        {
            return -1;
        }
        
        // Valida la puntuación
        if (!DataCollector.ValidateScore(score))
        {
            return -2;
        }
        
        // Establece la puntuación
        scoreGrid[studentIndex][assignmentIndex] = score;
        return 0;
    }
    
    public static int UpdateAllScores(int[][] scoreGrid, int[] studentIndices, int assignmentIndex, int score)
    {
        int successCount = 0;
        
        for (int i = 0; i < studentIndices.Length; i++)
        {
            int result = SetStudentScore(scoreGrid, studentIndices[i], assignmentIndex, score);
            if (result == 0)
            {
                successCount++;
            }
        }
        
        return successCount;
    }
}

public class DataAnalyzer
{
    public static double CalculateStudentAverage(int[][] scoreGrid, int studentIndex)
    {
        // Check if student index is valid
        if (studentIndex < 0 || studentIndex >= scoreGrid.Length)
        {
            return -1;
        }
        
        int sum = 0;
        int count = 0;
        
        // Calcula la suma de las puntuaciones válidas
        for (int j = 0; j < scoreGrid[studentIndex].Length; j++)
        {
            int score = scoreGrid[studentIndex][j];
            if (score != -1)  // Ignora las tareas sin calificar
            {
                sum += score;
                count++;
            }
        }
        
        // Devuelve el promedio o 0 si no hay puntuaciones válidas
        return count > 0 ? (double)sum / count : 0;
    }
    
    public static double CalculateAssignmentAverage(int[][] scoreGrid, int assignmentIndex)
    {
        // Comprueba si hay algún estudiante
        if (scoreGrid.Length == 0)
        {
            return -1;
        }
        
        // Check if assignment index is valid
        if (assignmentIndex < 0 || assignmentIndex >= scoreGrid[0].Length)
        {
            return -1;
        }
        
        int sum = 0;
        int count = 0;
        
        // Calcula la suma de las puntuaciones válidas para la tarea
        for (int i = 0; i < scoreGrid.Length; i++)
        {
            if (assignmentIndex < scoreGrid[i].Length)
            {
                int score = scoreGrid[i][assignmentIndex];
                if (score != -1)  // Ignora las tareas sin calificar
                {
                    sum += score;
                    count++;
                }
            }
        }
        
        // Devuelve el promedio o 0 si no hay puntuaciones válidas
        return count > 0 ? (double)sum / count : 0;
    }
    
    public static int[] FindHighestScore(int[][] scoreGrid)
    {
        int highestStudentIndex = 0;
        int highestAssignmentIndex = 0;
        int highestScore = -1;
        
        // Busca la puntuación más alta
        for (int i = 0; i < scoreGrid.Length; i++)
        {
            for (int j = 0; j < scoreGrid[i].Length; j++)
            {
                int currentScore = scoreGrid[i][j];
                if (currentScore > highestScore)
                {
                    highestScore = currentScore;
                    highestStudentIndex = i;
                    highestAssignmentIndex = j;
                }
            }
        }
        
        return new int[] { highestStudentIndex, highestAssignmentIndex, highestScore };
    }
}

Todas las lecciones de Lógica y Flujo

Practica por tu cuenta: Compilador de C# online