Menu
CoddyTech

Ausnahmen

Teil des Abschnitts C#- und .NET-Grundlagen der ASP.NET Core-Journey von Coddy. Lektion 17 von 20.

Wenn etwas fehlschlägt, löst .NET eine Ausnahme aus: ein Objekt, das das Problem beschreibt und eine Message enthält. Der restliche Code wird übersprungen, bis eine catch-Klausel für diesen Ausnahmetyp erreicht wird. Wird die Ausnahme von keiner Klausel abgefangen, wird das Programm beendet. finally wird in jedem Fall ausgeführt. Auch dein Code kann eine Ausnahme mit throw auslösen:

try
{
    var age = int.Parse(input);
    if (age < 0) throw new FormatException("An age cannot be negative.");
    Console.WriteLine($"Next year you are {age + 1}");
}
catch (FormatException ex)
{
    Console.WriteLine($"Not an age: {ex.Message}");
}

Fange die Ausnahmetypen ab, mit denen du rechnest und die du behandeln kannst, nicht jede Exception. Bei Eingaben, die häufig falsch sind, ist TryParse einfacher; eine Ausnahme eignet sich für ein Problem, das tief im Inneren eines anderen Codes auftritt.

challenge icon

Aufgabe

Mittel

Heute stoppt eine fehlerhafte Zeile import. Sorge dafür, dass fehlerhafte Zeilen übersprungen werden und die gültigen erhalten bleiben. Dein Projekt enthält bank-april.txt, dessen Zeilen 2 und 3 fehlerhaft sind.

  1. Zähle in der import-Schleife die Zeilen in lineNumber, beginnend bei 1 für die erste Zeile.
  2. Setze den Schleifenrumpf in ein try. Wenn die Zeile nicht in genau 3 Werte aufgeteilt wird, throw new FormatException("A line needs a name, an amount and a category.").
  3. Füge nach dem try catch (FormatException ex) ein und schreibe die Zeilennummer und ex.Message nach stderr. Dann fährt die Schleife mit der nächsten Zeile fort.

dotnet run -- import bank-april.txt schreibt diese beiden Zeilen nach stderr:

Line 2 skipped: The input string 'abc' was not in a correct format.
Line 3 skipped: A line needs a name, an amount and a category.

und gibt Imported 2 expenses from bank-april.txt. aus.

Probiere es aus: Im Terminal neben dem Editor steht bereits dotnet run -- import bank-april.txt. Drücke also auf „Ausführen“: Die Zeile Imported und darunter beide Meldungen in Rot aus stderr werden angezeigt. Ändere Zeile 2 in bank-april.txt zu Taxi,18.00,travel und drücke erneut auf „Ausführen“: Imported 3 expenses from bank-april.txt.

Probier es selbst

using System.Globalization;
using System.Text.Json;

var file = "expenses.json";
var expenses = new List<Expense>();
if (File.Exists(file))
{
    expenses = JsonSerializer.Deserialize<List<Expense>>(File.ReadAllText(file)) ?? new List<Expense>();
}
var budgets = new Dictionary<string, decimal>();
if (File.Exists("budgets.json"))
{
    budgets = JsonSerializer.Deserialize<Dictionary<string, decimal>>(File.ReadAllText("budgets.json")) ?? new Dictionary<string, decimal>();
}
var count = expenses.Count;
var total = expenses.Sum(e => e.Amount);

if (args.Length == 0)
{
    Console.WriteLine("Expense Tracker");
    Console.WriteLine($"{count} expenses");
    Console.WriteLine($"Total: {total:F2}");
}
else
{
    switch (args[0])
    {
        case "add":
            if (args.Length < 3)
            {
                Console.Error.WriteLine("Usage: add <name> <amount> [category]");
                return 1;
            }
            if (!decimal.TryParse(args[2], CultureInfo.InvariantCulture, out var amount))
            {
                Console.Error.WriteLine($"Invalid amount: {args[2]}");
                return 1;
            }
            if (amount is <= 0 or > 10000)
            {
                Console.Error.WriteLine("The amount must be more than 0 and at most 10000.");
                return 1;
            }
            var category = args.Length > 3 ? args[3] : "other";
            var expense = new Expense(args[1], amount, category);
            expenses.Add(expense);
            File.WriteAllText(file, JsonSerializer.Serialize(expenses));
            Console.WriteLine($"Added {expense.Name}: {expense.Amount:F2} ({expense.Category})");
            if (budgets.TryGetValue(category, out var limit))
            {
                var spent = expenses.Where(e => e.Category == category).Sum(e => e.Amount);
                if (spent > limit)
                {
                    Console.WriteLine($"Over budget for {category}: {spent:F2} of {limit:F2}");
                }
            }
            break;
        case "remove":
            if (args.Length < 2)
            {
                Console.Error.WriteLine("Usage: remove <name>");
                return 1;
            }
            Expense? match = expenses.Find(e => e.Name == args[1]);
            if (match is null)
            {
                Console.Error.WriteLine($"No expense named {args[1]}.");
                return 1;
            }
            expenses.Remove(match);
            File.WriteAllText(file, JsonSerializer.Serialize(expenses));
            Console.WriteLine($"Removed {match.Name}: {match.Amount:F2}");
            break;
        case "list":
            var shown = args.Length > 1 ? expenses.Where(e => e.Category == args[1]).ToList() : expenses;
            if (shown.Count == 0)
            {
                Console.WriteLine("No expenses.");
                break;
            }
            foreach (var line in shown.Select(e => $"{e.Name}: {e.Amount:F2} ({e.Category})"))
            {
                Console.WriteLine(line);
            }
            break;
        case "top":
            var howMany = 3;
            if (args.Length > 1 && !int.TryParse(args[1], out howMany))
            {
                Console.Error.WriteLine($"Invalid number: {args[1]}");
                return 1;
            }
            var biggest = expenses.OrderByDescending(e => e.Amount).Take(howMany);
            foreach (var line in biggest.Select((e, i) => $"{i + 1}. {e.Name}: {e.Amount:F2} ({e.Category})"))
            {
                Console.WriteLine(line);
            }
            break;
        case "categories":
            var groups = expenses.GroupBy(e => e.Category).OrderByDescending(g => g.Sum(e => e.Amount));
            foreach (var g in groups)
            {
                Console.WriteLine($"{g.Key}: {g.Sum(e => e.Amount):F2} ({g.Count()})");
            }
            break;
        case "help":
            var topic = args.Length > 1 ? args[1] : "";
            var help = topic switch
            {
                "" => "Type help <command>, such as help add.",
                "add" => "add <name> <amount> [category]: saves an expense",
                "remove" => "remove <name>: deletes the first expense with that name",
                "list" => "list [category]: shows the saved expenses",
                "top" => "top [n]: shows the n biggest expenses, 3 by default",
                "categories" => "categories: shows the total of each category",
                "import" => "import <file>: adds the expenses in a CSV file",
                _ => $"No help for {topic}.",
            };
            Console.WriteLine(help);
            break;
        case "import":
            if (args.Length < 2)
            {
                Console.Error.WriteLine("Usage: import <file>");
                return 1;
            }
            if (!File.Exists(args[1]))
            {
                Console.Error.WriteLine($"No file named {args[1]}.");
                return 1;
            }
            var imported = 0;
            foreach (var row in File.ReadAllLines(args[1]))
            {
                var parts = row.Split(',');
                expenses.Add(new Expense(parts[0], decimal.Parse(parts[1], CultureInfo.InvariantCulture), parts[2]));
                imported++;
            }
            File.WriteAllText(file, JsonSerializer.Serialize(expenses));
            Console.WriteLine($"Imported {imported} expenses from {args[1]}.");
            break;
        default:
            Console.Error.WriteLine($"Unknown command: {args[0]}");
            return 1;
    }
}
return 0;
quiz iconTeste dich selbst

Diese Lektion enthält ein kurzes Quiz. Starte die Lektion, um es zu beantworten und deinen Fortschritt zu speichern.

Alle Lektionen in C#- und .NET-Grundlagen