c# · level 3 check

a concurrent order processor.

Time to ship a real tool: an order processor. Each line typed is one order, written `customer,item,quantity,price`, like `ana,mug,2,4.50`. Every line is handled as its own task on the thread pool, and a sorted report comes out at the end, identical on every run.

Make it robust. `OrderParser.Parse` turns a line into a `Result<Order>`: an order, or the reason it was refused. `int.TryParse` returns `false` instead of crashing, and hands the number back through `out`, much like `ref`. Blank lines are skipped, names ignore capitals, and refused lines are listed by line number.

Tasks finish in any order, so totals go into a `ConcurrentDictionary` and the accepted count uses `Interlocked`. The report sorts customers by total, highest first, then by name. Fill in each `____`, then try it on orders of your own.

Your program

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

var lines = new List<string>();
string line = Console.ReadLine();
while (line != null)
{
    lines.Add(line);
    line = Console.ReadLine();
}

var processor = new OrderProcessor();
var jobs = new List<Task>();
for (int i = 0; i < lines.Count; i++)
{
    int number = i + 1;
    string text = lines[i];
    jobs.Add(Task.Run(() => processor.Handle(number, text)));
}
await Task.____(jobs);
Console.WriteLine(processor.Report());

record Order(string Customer, string Item, int Quantity, decimal Price)
{
    public decimal Total => Quantity * Price;
}

record Result<T>(T Value, string Error)
{
    public bool Ok => Error == null;
    public static Result<T> Success(T value) => new Result<T>(value, null);
    public static Result<T> Failure(string error) => new Result<T>(____, error);
}

static class OrderParser
{
    public static Result<Order> Parse(string text)
    {
        string[] parts = text.Split(',');
        if (parts.Length != 4)
        {
            return Result<Order>.Failure("expected customer,item,quantity,price");
        }
        string customer = parts[0].Trim().ToLowerInvariant();
        string item = parts[1].Trim().ToLowerInvariant();
        if (customer == "" || item == "")
        {
            return Result<Order>.Failure("customer and item must not be empty");
        }
        if (!int.TryParse(parts[2].Trim(), out int quantity) || quantity is ____)
        {
            return Result<Order>.Failure("quantity must be a whole number from 1 to 99");
        }
        if (!decimal.TryParse(parts[3].Trim(), NumberStyles.Number, CultureInfo.InvariantCulture, out decimal price) || price <= 0)
        {
            return Result<Order>.Failure("price must be a positive amount");
        }
        return Result<Order>.Success(new Order(customer, item, quantity, price));
    }
}

class OrderProcessor
{
    private readonly ConcurrentDictionary<string, decimal> totals = new ConcurrentDictionary<string, decimal>();
    private readonly ConcurrentDictionary<string, int> orderCounts = new ConcurrentDictionary<string, int>();
    private readonly ConcurrentDictionary<string, int> unitsSold = new ConcurrentDictionary<string, int>();
    private readonly ConcurrentDictionary<int, string> rejected = new ConcurrentDictionary<int, string>();
    private int accepted;

public void Handle(int number, string text)
    {
        if (string.IsNullOrWhiteSpace(text))
        {
            return;
        }
        Result<Order> result = OrderParser.Parse(text);
        if (!result.Ok)
        {
            rejected[number] = result.Error;
            return;
        }
        Order order = result.Value;
        totals.AddOrUpdate(order.Customer, order.Total, (key, old) => ____);
        orderCounts.AddOrUpdate(order.Customer, 1, (key, old) => old + 1);
        unitsSold.AddOrUpdate(order.Item, order.Quantity, (key, old) => old + order.Quantity);
        Interlocked.____(ref accepted);
    }

public string Report()
    {
        if (accepted == 0 && rejected.IsEmpty)
        {
            return "No orders to process.";
        }
        var report = new List<string> { $"Orders: {accepted} accepted, {rejected.Count} rejected" };
        var customers = totals.OrderByDescending(p => p.Value).____(p => p.Key, StringComparer.Ordinal);
        foreach (var pair in customers)
        {
            report.Add($"{pair.Key}: {pair.Value:0.00} ({Orders(orderCounts[pair.Key])})");
        }
        if (!unitsSold.IsEmpty)
        {
            var best = unitsSold.OrderByDescending(p => p.Value).ThenBy(p => p.Key, StringComparer.Ordinal).First();
            report.Add($"Best seller: {best.Key} ({best.Value})");
        }
        if (!rejected.IsEmpty)
        {
            report.Add("Rejected:");
            report.AddRange(rejected.OrderBy(p => p.Key).Select(p => $"line {p.Key}: {p.Value}"));
        }
        return string.Join("\n", report);
    }

private static string Orders(int count) => count switch
    {
        1 => "1 order",
        _ => $"{count} orders",
    };
}

Fill in every ____ then run the checks.

1 It totals each customer's ordersuses: ConcurrentDictionary
2 It sorts by total, highest first, then by nameuses: LINQ
3 It refuses bad lines and says whyuses: pattern matching
4 It ignores capitals, spaces and blank linesuses: edge cases
5 It copes with a flood of orders at onceuses: Interlocked
6 It says so when there is nothing to douses: edge cases

Take as long as you like and try as many times as you want.

a concurrent order processor.

level up.

playground