Composition Root

using System;
using System.Collections.Generic;

//client code
var app = ShopApp.Loud();
app.UseCase.Place([("pen", 2), ("lamp", 1)]);
app.UseCase.Place([("chair", 1)]);

//a second root builds the same use case differently
var night = ShopApp.Quiet();
night.UseCase.Place([("lamp", 1)]);
Console.WriteLine($"saved {night.Orders.Count}");
//printed: order 1001 for 225
//         no chair
//         saved 1

//entity
record Order(int Id, int Total)
{
    public int Payable =>
        Total >= 200 ? Total - Total / 10 : Total;
}

//gateway
interface ICatalog
{
    int? Price(string sku);
}

//repository
interface IOrders
{
    void Save(Order order);

    int Count { get; }
}

//output port
interface IReport
{
    void Say(string text);
}

//use case: asks for its parts, never builds them
sealed class PlaceOrder(
    ICatalog catalog,
    IOrders orders,
    IReport report)
{
    private int nextId = 1001;

    public void Place(
        IReadOnlyList<(string Sku, int Count)> items)
    {
        int total = 0;
        foreach (var (sku, count) in items)
        {
            if (catalog.Price(sku) is not int price)
            {
                report.Say($"no {sku}");
                return;
            }
            total += price * count;
        }
        var order = new Order(nextId++, total);
        orders.Save(order);
        report.Say(
            $"order {order.Id} for {order.Payable}");
    }
}

//adapter
sealed class MemoryCatalog : ICatalog
{
    public int? Price(string sku) => sku switch
    {
        "pen" => 30,
        "lamp" => 190,
        _ => null,
    };
}

//adapter
sealed class MemoryOrders : IOrders
{
    private readonly List<Order> rows = [];

    public void Save(Order order) => rows.Add(order);

    public int Count => rows.Count;
}

//adapter
sealed class ConsoleReport : IReport
{
    public void Say(string text) =>
        Console.WriteLine(text);
}

//adapter
sealed class SilentReport : IReport
{
    public void Say(string text)
    {
    }
}

//composition root: the only place that sees every layer
//at once, and the only place where an adapter is built
sealed class ShopApp
{
    private ShopApp(
        ICatalog catalog,
        IOrders orders,
        IReport report)
    {
        Orders = orders;
        UseCase = new PlaceOrder(catalog, orders, report);
    }

    public PlaceOrder UseCase { get; }

    public IOrders Orders { get; }

    public static ShopApp Loud() => new(
        new MemoryCatalog(),
        new MemoryOrders(),
        new ConsoleReport());

    public static ShopApp Quiet() => new(
        new MemoryCatalog(),
        new MemoryOrders(),
        new SilentReport());
}