Menu
CoddyTech

Excepciones

Parte de la sección Conceptos básicos de C# y .NET del Journey de ASP.NET Core de Coddy. Lección 17 de 20.

Cuando algo falla, .NET lanza una excepción: un objeto que describe el problema, con un Message. Omite el resto del código hasta encontrar un catch para ese tipo de excepción y, si ninguno la captura, el programa se detiene. finally se ejecuta en ambos casos. Tu código también puede throw una:

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}");
}

Captura los tipos de excepción que esperas y puedes manejar, no cualquier Exception. Para entradas que suelen ser incorrectas, TryParse es más sencillo; una excepción es adecuada para un problema que se detecta en lo profundo de otro código.

challenge icon

Desafío

Intermedio

Hoy, una sola línea incorrecta detiene import. Haz que omita las líneas incorrectas y conserve las correctas. Tu proyecto tiene bank-april.txt, cuyas líneas 2 y 3 son incorrectas.

  1. En el bucle de import, cuenta las líneas en lineNumber, empezando por 1 para la primera línea.
  2. Pon el cuerpo del bucle dentro de un try. Cuando la línea no se divida en exactamente 3 valores, throw new FormatException("A line needs a name, an amount and a category.").
  3. Después del try, usa catch (FormatException ex) y escribe el número de línea y ex.Message en stderr. Después, el bucle continúa con la siguiente línea.

dotnet run -- import bank-april.txt escribe estas dos líneas en 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.

y muestra Imported 2 expenses from bank-april.txt.

Pruébalo: el terminal junto al editor ya muestra dotnet run -- import bank-april.txt, así que pulsa Ejecutar: aparecerá la línea Imported y, debajo, ambos mensajes en rojo, procedentes de stderr. Corrige la línea 2 de bank-april.txt para que diga Taxi,18.00,travel y vuelve a pulsar Ejecutar: Imported 3 expenses from bank-april.txt.

Pruébalo tú mismo

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 iconPonte a prueba

Esta lección incluye un breve cuestionario. Empieza la lección para responderlo y registrar tu progreso.

Todas las lecciones de Conceptos básicos de C# y .NET