Menu
CoddyTech

Async et Await

Fait partie de la section Bases de C# et .NET du Journey ASP.NET Core de Coddy. Leçon 19 sur 20.

La lecture d’un fichier ou l’appel à un serveur fait attendre un programme. Une méthode async renvoie immédiatement une Task (ou une Task<T> pour un résultat), et await attend son résultat sans bloquer le thread, qui peut effectuer d’autres tâches pendant ce temps. Une méthode qui utilise await est marquée async, et les instructions de niveau supérieur peuvent utiliser directement await.

async Task<int> LengthAsync(string path)
{
    var text = await File.ReadAllTextAsync(path);
    return text.Length;
}
var first = LengthAsync("a.txt");
var second = LengthAsync("b.txt");
int[] lengths = await Task.WhenAll(first, second);

Les deux lectures s’exécutent en même temps, et Task.WhenAll attend les deux. Par convention, les méthodes qui renvoient une tâche se terminent par Async. Un serveur attend toute la journée des fichiers, des bases de données et d’autres serveurs ; les gestionnaires d’ASP.NET Core utilisent ce même await.

challenge icon

Défi

Moyen

Fais en sorte que export écrive aussi un fichier par catégorie, avec la méthode de fichier asynchrone.

  1. Dans le cas export, après la ligne Exported, parcours les dépenses regroupées par catégorie.
  2. Pour chaque groupe, construis le chemin exports/food.csv (la catégorie, puis .csv) avec Path.Combine. Écris les lignes du groupe, au même format CSV que expenses.csv, avec await File.WriteAllLinesAsync.
  3. Après chaque fichier, affiche Wrote exports/food.csv avec son chemin.

Avec les trois dépenses de expenses.json, dotnet run -- export affiche :

Exported 3 expenses to exports/expenses.csv.
Wrote exports/food.csv
Wrote exports/travel.csv

et exports/travel.csv contient la seule ligne Train,4.20,travel.

Essaie : le terminal à côté de l’éditeur contient déjà dotnet run -- export, alors appuie sur Exécuter : les trois lignes ci-dessus s’affichent. Remplace la catégorie de Groceries dans expenses.json par home, puis appuie de nouveau sur Exécuter : une troisième ligne apparaît, Wrote exports/home.csv.

Essayez vous-même

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",
                "export" => "export: writes every expense to exports/expenses.csv",
                _ => $"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;
            var lineNumber = 0;
            foreach (var row in File.ReadAllLines(args[1]))
            {
                lineNumber++;
                try
                {
                    var parts = row.Split(',');
                    if (parts.Length != 3)
                    {
                        throw new FormatException("A line needs a name, an amount and a category.");
                    }
                    expenses.Add(new Expense(parts[0], decimal.Parse(parts[1], CultureInfo.InvariantCulture), parts[2]));
                    imported++;
                }
                catch (FormatException ex)
                {
                    Console.Error.WriteLine($"Line {lineNumber} skipped: {ex.Message}");
                }
            }
            File.WriteAllText(file, JsonSerializer.Serialize(expenses));
            Console.WriteLine($"Imported {imported} expenses from {args[1]}.");
            break;
        case "export":
            var folder = "exports";
            Directory.CreateDirectory(folder);
            var csvPath = Path.Combine(folder, "expenses.csv");
            File.WriteAllLines(csvPath, expenses.Select(e => $"{e.Name},{e.Amount.ToString("F2", CultureInfo.InvariantCulture)},{e.Category}"));
            Console.WriteLine($"Exported {expenses.Count} expenses to {csvPath}.");
            break;
        default:
            Console.Error.WriteLine($"Unknown command: {args[0]}");
            return 1;
    }
}
return 0;
quiz iconTestez-vous

Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.

Toutes les leçons de Bases de C# et .NET