Exception Types

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

In C# werden Ausnahmen in verschiedene Typen kategorisiert, basierend auf dem Fehler, den sie darstellen. Das Verständnis dieser Typen hilft Ihnen, Fehler effektiver zu behandeln.

Lassen Sie uns die gängigen Ausnahmetypen betrachten:

Die Basisklasse für alle Ausnahmen ist System.Exception.

try
{
    // Code, der eine Ausnahme werfen könnte
}
catch (Exception ex)
{
    // Beliebige Ausnahme behandeln
    Console.WriteLine(ex.Message);
}

Einige gängige Ausnahmetypen:

ArgumentException: Wird geworfen, wenn eine Methode mit einem ungültigen Argument aufgerufen wird.

string name = null;
if (name == null)
{
    throw new ArgumentException("Name cannot be null");
}

NullReferenceException: Wird ausgelöst, wenn Sie versuchen, auf ein Mitglied einer null-Referenz zuzugreifen.

string text = null;
// This will throw NullReferenceException
int length = text.Length;

IndexOutOfRangeException: Wird ausgelöst, wenn ein Array-Index außerhalb der Grenzen des Arrays liegt.

int[] numbers = { 1, 2, 3 };
// This will throw IndexOutOfRangeException
int value = numbers[5];

DivideByZeroException: Wird ausgelöst, wenn eine Ganzzahl durch Null geteilt wird.

int result = 10 / 0; // Dies löst eine DivideByZeroException aus

Sie können spezifische Ausnahmen abfangen:

try
{
    int[] numbers = { 1, 2, 3 };
    int value = numbers[5];
}
catch (IndexOutOfRangeException ex)
{
    Console.WriteLine("Array index error: " + ex.Message);
}
catch (Exception ex)
{
    Console.WriteLine("General error: " + ex.Message);
}

Aufgabe

Einfach

Erstellen Sie eine Methode namens ProcessArray, die:

Nimmt ein Array von Ganzzahlen und einen Index als Parameter
Versucht, auf das Element am angegebenen Index zuzugreifen
Gibt den Elementwert zurück, wenn erfolgreich
Falls eine IndexOutOfRangeException auftritt, fangen Sie sie ab und geben -1 zurück

Ihre Methode sollte diese Signatur haben:

public static int ProcessArray(int[] array, int index)

Spickzettel

Die Basisklasse für alle Ausnahmen ist System.Exception:

try
{
    // Code that might throw an exception
}
catch (Exception ex)
{
    // Handle any exception
    Console.WriteLine(ex.Message);
}

Häufige Ausnahmetypen:

ArgumentException: Wird geworfen, wenn eine Methode mit einem ungültigen Argument aufgerufen wird:

string name = null;
if (name == null)
{
    throw new ArgumentException("Name cannot be null");
}

NullReferenceException: Wird geworfen, wenn auf ein Mitglied einer null-Referenz zugegriffen wird:

string text = null;
int length = text.Length; // Throws NullReferenceException

IndexOutOfRangeException: Wird geworfen, wenn der Array-Index außerhalb der Grenzen liegt:

int[] numbers = { 1, 2, 3 };
int value = numbers[5]; // Throws IndexOutOfRangeException

DivideByZeroException: Wird geworfen, wenn eine Ganzzahl durch Null geteilt wird:

int result = 10 / 0; // Throws DivideByZeroException

Spezifische Ausnahmen abfangen:

try
{
    int[] numbers = { 1, 2, 3 };
    int value = numbers[5];
}
catch (IndexOutOfRangeException ex)
{
    Console.WriteLine("Array index error: " + ex.Message);
}
catch (Exception ex)
{
    Console.WriteLine("General error: " + ex.Message);
}

Probier es selbst

using System;

class Program
{
    public static int ProcessArray(int[] array, int index)
    {
        // Schreibe hier deinen Code
        return 0;
    }

    static void Main(string[] args)
    {
        // Array-Eingabe lesen
        string input = Console.ReadLine();
        
        // Klammern entfernen falls vorhanden
        if (input.StartsWith("[") && input.EndsWith("]"))
        {
            input = input.Substring(1, input.Length - 2);
        }
        
        string[] parts = input.Split(',');
        
        int[] array = new int[parts.Length];
        for (int i = 0; i < parts.Length; i++)
        {
            array[i] = int.Parse(parts[i].Trim());
        }
        
        // Index-Eingabe lesen
        int index = int.Parse(Console.ReadLine());
        
        int result = ProcessArray(array, index);
        Console.WriteLine(result);
    }
}