Menu
CoddyTech

Eine CSV-Datei lesen

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

Banken und Tabellenkalkulationen exportieren Daten als CSV: ein Datensatz pro Zeile, mit Kommas zwischen den Werten. File.ReadAllLines(path) gibt die Zeilen einer Datei als string[] zurück, und line.Split(',') teilt eine Zeile an jedem Komma auf:

foreach (var line in File.ReadAllLines("scores.txt"))
{
    var parts = line.Split(',');
    var points = int.Parse(parts[1]);
    Console.WriteLine($"{parts[0]} scored {points}");
}

Für eine Zeile Ada,42 gibt dies Ada scored 42 aus. Eine fehlende Datei löst eine FileNotFoundException aus, prüfe daher zuerst File.Exists. File.ReadLines erledigt dieselbe Aufgabe Zeile für Zeile und eignet sich daher für Dateien, die zu groß sind, um sie im Arbeitsspeicher zu halten. In echten CSV-Dateien können Kommas innerhalb von Werten in Anführungszeichen stehen; eine CSV-Bibliothek kann damit umgehen, und die Dateien hier enthalten keine solchen Kommas.

challenge icon

Aufgabe

Einfach

Dein Projekt enthält jetzt bank.txt mit drei Ausgaben im CSV-Format. Füge einen Befehl import hinzu, der die Zeilen einer solchen Datei hinzufügt.

  1. Füge case "import": oberhalb von default: hinzu. Wenn kein Dateiname angegeben ist, gib Usage: import <file> auf stderr aus und führe return 1; aus. Wenn die Datei nicht existiert, gib No file named nope.txt. (mit dem angegebenen Namen) auf stderr aus und führe return 1; aus.
  2. Teile jede Zeile an den Kommas auf und füge ein Expense mit dem Namen, dem mit decimal.Parse und CultureInfo.InvariantCulture geparsten Betrag sowie der Kategorie hinzu. Zähle die hinzugefügten Zeilen.
  3. Speichere die Liste einmal nach der Schleife und gib Folgendes aus:
    Imported 3 expenses from bank.txt.
  4. Füge help oberhalb von _ einen Zweig dafür hinzu: help import gibt import <file>: adds the expenses in a CSV file aus.

Probier es aus: Das Terminal neben dem Editor enthält bereits dotnet run -- import bank.txt. Drücke also auf „Ausführen“: die Zeile oben. Füge die Zeile Lamp,25.00,home zu bank.txt hinzu und drücke erneut auf „Ausführen“: Imported 4 expenses from bank.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",
                _ => $"No help for {topic}.",
            };
            Console.WriteLine(help);
            break;
        default:
            Console.Error.WriteLine($"Unknown command: {args[0]}");
            return 1;
    }
}
return 0;

Alle Lektionen in C#- und .NET-Grundlagen