Fehlerbehandlung

Teil des Abschnitts Logik & Ablauf der C#-Journey von Coddy. Lektion 45 von 66.

Aufgabe

Einfach

Erweitern wir unser System um eine robuste Fehlerbehandlung, damit potenzielle Probleme ordnungsgemäß behandelt werden. Erstelle eine Klasse namens ErrorHandler mit diesen Methoden:

ValidateInput(int[][] scoreGrid, int studentIndex, int assignmentIndex): Überprüft die Eingabeindizes und gibt eine passende Fehlermeldung oder eine leere Zeichenfolge zurück, wenn sie gültig sind.
- Gibt "Invalid student index" zurück, wenn der Studentenindex außerhalb der gültigen Grenzen liegt.
- Gibt "Invalid assignment index" zurück, wenn der Aufgabenindex außerhalb der gültigen Grenzen liegt.
- Gibt eine leere Zeichenfolge "" zurück, wenn beide Indizes gültig sind.
SafeGetScore(int[][] scoreGrid, int studentIndex, int assignmentIndex): Ruft eine Punktzahl sicher mit Fehlerbehandlung ab.
- Gibt die Punktzahl zurück, wenn beide Indizes gültig sind.
- Gibt -999 zurück, wenn ein Index ungültig ist.
ProcessBatchUpdate(int[][] scoreGrid, int[][] updates): Verarbeitet Stapelaktualisierungen, bei denen jede Aktualisierung [studentIndex, assignmentIndex, score] ist.
- Gibt ein string[]-Array mit Fehlermeldungen für jede fehlgeschlagene Aktualisierung zurück.
- Jede Aktualisierung kann mit einer dieser spezifischen Fehlermeldungen fehlschlagen:
  - "Invalid update format", wenn die Aktualisierung nicht genau 3 Werte enthält.
  - "Invalid student index": wenn der Studentenindex außerhalb der gültigen Grenzen liegt.
  - "Invalid assignment index": wenn der Aufgabenindex außerhalb der gültigen Grenzen liegt.
  - "Invalid score value": wenn die Punktzahl außerhalb des gültigen Bereichs (0-100) liegt.
- Formatiere jeden Fehler als: "Error at index X: [specific error message]"
- Gib ein leeres Array zurück, wenn alle Aktualisierungen erfolgreich sind.

Hinweis: Um Fehler dynamisch zu sammeln, bevor du sie als string[] zurückgibst, verwende List<string> errors = new List<string>();. List<string> funktioniert wie ein größenveränderbares Array, an das du mit errors.Add(...) Elemente anhängen kannst. Wandle es am Ende mit errors.ToArray() um. Der dafür benötigte Import using System.Collections.Generic; ist bereits am Anfang der Datei enthalten.

Probier es selbst

using System; // Diese Zeile nicht löschen
using System.Collections.Generic;

public class ErrorHandler
{
    public static string ValidateInput(int[][] scoreGrid, int studentIndex, int assignmentIndex)
    {
        // Schreibe deinen Code hier
        
    }
    
    public static int SafeGetScore(int[][] scoreGrid, int studentIndex, int assignmentIndex)
    {
        // Schreibe deinen Code hier
        
    }
    
    public static string[] ProcessBatchUpdate(int[][] scoreGrid, int[][] updates)
    {
        // Schreibe deinen Code hier
        
    }
}

// Erforderlich für Tests - nicht ändern
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)
    {
        // Auf Indizes außerhalb des gültigen Bereichs prüfen
        if (studentIndex < 0 || studentIndex >= scoreGrid.Length || 
            assignmentIndex < 0 || assignmentIndex >= scoreGrid[studentIndex].Length)
        {
            return -1;
        }
        
        // Die Punktzahl validieren
        if (!DataCollector.ValidateScore(score))
        {
            return -2;
        }
        
        // Die Punktzahl setzen
        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;
        
        // Summe der gültigen Punktzahlen berechnen
        for (int j = 0; j < scoreGrid[studentIndex].Length; j++)
        {
            int score = scoreGrid[studentIndex][j];
            if (score != -1)  // Nicht bewertete Aufgaben ignorieren
            {
                sum += score;
                count++;
            }
        }
        
        // Durchschnitt zurückgeben oder 0, wenn keine gültigen Punktzahlen
        return count > 0 ? (double)sum / count : 0;
    }
    
    public static double CalculateAssignmentAverage(int[][] scoreGrid, int assignmentIndex)
    {
        // Prüfen, ob es Schüler gibt
        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;
        
        // Summe der gültigen Punktzahlen für die Aufgabe berechnen
        for (int i = 0; i < scoreGrid.Length; i++)
        {
            if (assignmentIndex < scoreGrid[i].Length)
            {
                int score = scoreGrid[i][assignmentIndex];
                if (score != -1)  // Nicht bewertete Aufgaben ignorieren
                {
                    sum += score;
                    count++;
                }
            }
        }
        
        // Durchschnitt zurückgeben oder 0, wenn keine gültigen Punktzahlen
        return count > 0 ? (double)sum / count : 0;
    }
    
    public static int[] FindHighestScore(int[][] scoreGrid)
    {
        int highestStudentIndex = 0;
        int highestAssignmentIndex = 0;
        int highestScore = -1;
        
        // Nach der höchsten Punktzahl suchen
        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 };
    }
}