Gestion des erreurs

Fait partie de la section Logique & Flux du Journey C# de Coddy. Leçon 45 sur 66.

Défi

Facile

Améliorons notre système avec une gestion robuste des erreurs afin de traiter correctement les problèmes potentiels. Créez une classe appelée ErrorHandler avec ces méthodes :

ValidateInput(int[][] scoreGrid, int studentIndex, int assignmentIndex) : valide les indices d'entrée et renvoie un message d'erreur approprié ou une chaîne vide si l'entrée est valide.
- Renvoie "Invalid student index" si l'indice de l'étudiant est hors limites.
- Renvoie "Invalid assignment index" si l'indice du devoir est hors limites.
- Renvoie une chaîne vide "" si les deux indices sont valides.
SafeGetScore(int[][] scoreGrid, int studentIndex, int assignmentIndex) : récupère un score de manière sécurisée avec une gestion des erreurs.
- Renvoie le score si les deux indices sont valides.
- Renvoie -999 si un indice quelconque est invalide.
ProcessBatchUpdate(int[][] scoreGrid, int[][] updates) : traite les mises à jour par lots, chaque mise à jour étant [studentIndex, assignmentIndex, score].
- Renvoie un tableau string[] de messages d'erreur pour chaque mise à jour échouée.
- Chaque mise à jour peut échouer avec l'un des messages d'erreur spécifiques suivants :
  - "Invalid update format", si la mise à jour ne contient pas exactement 3 valeurs.
  - "Invalid student index" : si l'indice de l'étudiant est hors limites.
  - "Invalid assignment index" : si l'indice du devoir est hors limites.
  - "Invalid score value" : si le score se trouve en dehors de la plage valide (0-100).
- Formatez chaque erreur ainsi : "Error at index X: [specific error message]"
- Renvoie un tableau vide si toutes les mises à jour réussissent.

Astuce : Pour collecter dynamiquement les erreurs avant de les renvoyer sous forme de string[], utilisez List<string> errors = new List<string>();. List<string> fonctionne comme un tableau redimensionnable dans lequel vous pouvez appeler errors.Add(...) pour ajouter des éléments. À la fin, convertissez-le avec errors.ToArray(). L'importation using System.Collections.Generic; nécessaire à cette opération est déjà incluse en haut du fichier.

Essayez vous-même

using System; // Ne supprimez pas cette ligne
using System.Collections.Generic;

public class ErrorHandler
{
    public static string ValidateInput(int[][] scoreGrid, int studentIndex, int assignmentIndex)
    {
        // Écrivez votre code ici
        
    }
    
    public static int SafeGetScore(int[][] scoreGrid, int studentIndex, int assignmentIndex)
    {
        // Écrivez votre code ici
        
    }
    
    public static string[] ProcessBatchUpdate(int[][] scoreGrid, int[][] updates)
    {
        // Écrivez votre code ici
        
    }
}

// Requis pour les tests - ne pas modifier
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)
    {
        // Vérifier les indices hors limites
        if (studentIndex < 0 || studentIndex >= scoreGrid.Length || 
            assignmentIndex < 0 || assignmentIndex >= scoreGrid[studentIndex].Length)
        {
            return -1;
        }
        
        // Valider le score
        if (!DataCollector.ValidateScore(score))
        {
            return -2;
        }
        
        // Définir le score
        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;
        
        // Calculer la somme des scores valides
        for (int j = 0; j < scoreGrid[studentIndex].Length; j++)
        {
            int score = scoreGrid[studentIndex][j];
            if (score != -1)  // Ignorer les devoirs non notés
            {
                sum += score;
                count++;
            }
        }
        
        // Retourner la moyenne ou 0 s'il n'y a pas de scores valides
        return count > 0 ? (double)sum / count : 0;
    }
    
    public static double CalculateAssignmentAverage(int[][] scoreGrid, int assignmentIndex)
    {
        // Vérifier s'il y a des étudiants
        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;
        
        // Calculer la somme des scores valides pour le devoir
        for (int i = 0; i < scoreGrid.Length; i++)
        {
            if (assignmentIndex < scoreGrid[i].Length)
            {
                int score = scoreGrid[i][assignmentIndex];
                if (score != -1)  // Ignorer les devoirs non notés
                {
                    sum += score;
                    count++;
                }
            }
        }
        
        // Retourner la moyenne ou 0 s'il n'y a pas de scores valides
        return count > 0 ? (double)sum / count : 0;
    }
    
    public static int[] FindHighestScore(int[][] scoreGrid)
    {
        int highestStudentIndex = 0;
        int highestAssignmentIndex = 0;
        int highestScore = -1;
        
        // Rechercher le score le plus élevé
        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 };
    }
}

Toutes les leçons de Logique & Flux

Entraînez-vous par vous-même : Compilateur C# en ligne