Menu
CoddyTech

Expresiones switch

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

Una expresión switch elige un valor comparando patrones. Primero va el valor, después switch y, a continuación, las ramas con la forma pattern => result, separadas por comas. Las ramas se prueban de arriba abajo y gana la primera coincidencia. _ coincide con cualquier cosa, así que va al final:

var text = status switch
{
    200 => "OK",
    404 => "Not Found",
    >= 500 => "Server Error",
    _ => "Other",
};

Sin _, el compilador advierte (CS8509) que algunos valores no tienen una rama y, si se da uno de esos valores, se produce una excepción SwitchExpressionException en tiempo de ejecución. Una instrucción switch ejecuta código para cada caso; una expresión switch produce un valor que puedes almacenar o imprimir.

challenge icon

Desafío

Fácil

Añade un comando help que explique cada comando mediante una expresión switch.

  1. Añade case "help": encima de default:. El tema es args[1] o "" si no hay ninguno.
  2. Asigna un valor a help mediante una expresión switch sobre el tema, con una rama por cada línea de abajo, y luego imprímelo:
    ""            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
  3. La última rama, _, devuelve No help for fly., con el tema en lugar de fly.

Pruébalo: el terminal junto al editor ya muestra dotnet run -- help add, así que pulsa «Ejecutar»: add <name> <amount> [category]: saves an expense. Cambia los argumentos por help fly y vuelve a pulsar «Ejecutar»: No help for fly. Si escribes solo help, verás Type help <command>, such as help add.

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;
        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