Menu
CoddyTech

Async ו-Await

חלק מהיחידה יסודות C# ו-.NET במסלול ה-ASP.NET Core של Coddy. שיעור 19 מתוך 20.

קריאה מקובץ או פנייה לשרת גורמות לתוכנית להמתין. מתודה async מחזירה מיד Task (או Task<T> כשיש תוצאה), ו-await ממתין לה בלי לחסום את התהליכון, כך שהוא יכול לבצע בינתיים עבודה אחרת. מתודה שמשתמשת ב-await מסומנת ב-async, והצהרות ברמה העליונה יכולות להשתמש ישירות ב-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);

שתי הקריאות מתבצעות בו-זמנית, ו-Task.WhenAll ממתין לשתיהן. לפי המוסכמה, שמותיהן של מתודות שמחזירות משימה מסתיימים ב-Async. שרת ממתין כל היום לקבצים, למסדי נתונים ולשרתים אחרים; המטפלים של ASP.NET Core משתמשים באותו await.

challenge icon

אתגר

בינוני

גרמו ל־export לכתוב גם קובץ אחד לכל קטגוריה, באמצעות מתודת הקובץ האסינכרונית.

  1. במקרה export, אחרי שורת Exported, עברו בלולאה על ההוצאות המקובצות לפי קטגוריה.
  2. לכל קבוצה, בנו את הנתיב exports/food.csv (הקטגוריה, ואחריה .csv) באמצעות Path.Combine. כתבו את השורות של הקבוצה, באותו פורמט CSV כמו expenses.csv, באמצעות await File.WriteAllLinesAsync.
  3. אחרי כל קובץ, הדפיסו Wrote exports/food.csv יחד עם הנתיב שלו.

עם שלוש ההוצאות שב־expenses.json, הפקודה dotnet run -- export מדפיסה:

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

והקובץ exports/travel.csv מכיל את השורה היחידה Train,4.20,travel.

נסו זאת: הטרמינל שלצד העורך כבר מכיל את הפקודה dotnet run -- export, אז לחצו על הרצה: שלוש השורות שלמעלה. שנו את הקטגוריה של Groceries ב־expenses.json ל־home ולחצו שוב על הרצה: תופיע שורה שלישית, Wrote exports/home.csv.

נסו בעצמכם

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 iconבחנו את עצמכם

השיעור הזה כולל חידון קצר. התחילו את השיעור כדי לענות עליו ולעקוב אחרי ההתקדמות.

כל השיעורים ביחידה יסודות C# ו-.NET