Shopping Cart

Every online store has one. Amazon, Flipkart, Shopify — they all start with the same deceptively simple feature: a shopping cart. Add items, see the total, checkout. Takes maybe 20 lines of code. But what happens when you need discount strategies — percentage off, buy-one-get-one, coupon codes? When products can be bundled — a laptop + mouse + bag as a single "Back to School" combo, and that combo can be inside another combo? When the cart needs to notify the UI when prices change, stock runs out, or a coupon expires? That 20-line cart becomes a real design problem with 3 patterns hiding inside it.

We're going to build this cart 7 times — each time adding ONE constraintA real-world requirement that forces your code to evolve. Each constraint is something the BUSINESS says, not a technical exercise. "The store needs bundle pricing" is a constraint. "Use the Composite pattern" is not — that's a solution you DISCOVER. that breaks your previous code. You'll feel the pain, discover the fix, and understand WHY the design exists. By Level 7, you'll have a production-grade e-commerce cart — and a set of reusable thinking tools that work for any system.

Before we write a single line of code, let's walk through a real online shopping experience. Not on a whiteboard — in your head. Imagine you're on Amazon or Flipkart. Watch what happens at every step, and notice every thing (noun) and every action (verb). These become your classes, methods, and data types — for free.

The real world is your first diagram. We found 8 entities, 3 design patterns, and a clear picture of the system — without writing a single line of code. Senior engineers start here.

Every complex e-commerce system starts with a laughably simple version. For a shopping cart, that means: a product with a name and price, a cart item that tracks quantity, and a cart that sums up subtotals. That's it. No tax calculations, no discount logic, no nothing. The goal of Level 0 is to get something working — then let the next constraint break it.

Your Internal Monologue

"OK, simplest shopping cart... I need a Product. What's the minimum? An ID to identify it, a name for display, and a price. Does price ever change? Not in the cart — the product page sets it. So Product is immutableData that never changes after creation. A product's price of $29.99 is a fact. If the store wants to change it, they create a new product entry — the existing carts keep their original price. This prevents surprising price changes mid-checkout. — a record."

"CartItem? That's a product + a quantity. Quantity changes (user hits +/- buttons), so CartItem needs to be a class, not a record. Subtotal is just price × quantity — a computed propertyA property that calculates its value on the fly instead of storing it. Subtotal => Product.Price * Quantity always returns the correct value, even if Quantity changes. No stored state to get out of sync., not stored."

"For the cart itself... should I use a Dictionary<string, int> mapping product IDs to quantities? Quick and dirty... but then I lose the product reference and can't compute subtotals without looking it up again. A List<CartItem> is cleaner — each entry has everything it needs."

// Quick and dirty: map product ID → quantity
var cart = new Dictionary<string, int>();

void AddToCart(string productId)
{
    if (cart.ContainsKey(productId))
        cart[productId]++;
    else
        cart[productId] = 1;
}

// Problem: where's the price? the product name?
// You need ANOTHER dictionary for that.
// GetTotal() requires a lookup service just to find prices.

public readonly record struct Product(string Id, string Name, decimal Price);

public class CartItem
{
    public Product Product { get; }
    public int Quantity { get; set; }
    public decimal Subtotal => Product.Price * Quantity;

    public CartItem(Product product, int quantity = 1)
    {
        Product = product;
        Quantity = quantity;
    }
}

public class ShoppingCart
{
    private readonly List<CartItem> _items = new();
    public IReadOnlyList<CartItem> Items => _items;
    public decimal Total => _items.Sum(i => i.Subtotal);
    // ... AddItem, RemoveItem
}

Here's the complete Level 0 code. Three types, under 40 lines. Read every line — we'll evolve each one.

/// <summary>
/// A product in the store catalog.
/// Immutable — once created, its data never changes.
/// </summary>
public readonly record struct Product(
    string Id,       // unique identifier (e.g., "LAPTOP-1")
    string Name,     // display name (e.g., "MacBook Air M3")
    decimal Price    // unit price in dollars
);

/// <summary>
/// One line in the shopping cart: a product + how many.
/// Quantity is mutable (user can hit +/- buttons).
/// </summary>
public class CartItem
{
    public Product Product { get; }
    public int Quantity { get; set; }

    /// Computed property — always in sync, no stored state
    public decimal Subtotal => Product.Price * Quantity;

    public CartItem(Product product, int quantity = 1)
    {
        Product = product;
        Quantity = quantity;
    }
}

public class ShoppingCart
{
    private readonly List<CartItem> _items = new();

    /// Read-only view — callers can see items but can't modify the list directly
    public IReadOnlyList<CartItem> Items => _items;

    /// Total = sum of all line subtotals
    public decimal Total => _items.Sum(item => item.Subtotal);

    /// Add a product. If it's already in the cart, increase quantity.
    public void AddItem(Product product, int quantity = 1)
    {
        var existing = _items.FirstOrDefault(i => i.Product.Id == product.Id);
        if (existing is not null)
        {
            existing.Quantity += quantity;
        }
        else
        {
            _items.Add(new CartItem(product, quantity));
        }
    }

    /// Remove a product entirely from the cart.
    public bool RemoveItem(string productId)
    {
        var item = _items.FirstOrDefault(i => i.Product.Id == productId);
        if (item is null) return false;
        _items.Remove(item);
        return true;
    }
}

var laptop = new Product("LAPTOP-1", "MacBook Air M3", 999.00m);
var mouse  = new Product("MOUSE-1",  "Logitech MX Master", 89.99m);
var cable  = new Product("CABLE-1",  "USB-C Cable 2m", 12.99m);

var cart = new ShoppingCart();
cart.AddItem(laptop);           // 1 laptop
cart.AddItem(mouse, 2);         // 2 mice
cart.AddItem(cable);            // 1 cable
cart.AddItem(laptop);           // adds another laptop (qty → 2)

foreach (var item in cart.Items)
    Console.WriteLine($"  {item.Product.Name} × {item.Quantity} = {item.Subtotal:C}");

Console.WriteLine($"  Total: {cart.Total:C}");
// Output:
//   MacBook Air M3 × 2 = $1,998.00
//   Logitech MX Master × 2 = $179.98
//   USB-C Cable 2m × 1 = $12.99
//   Total: $2,190.97

Let's walk through what each piece does:

• Product record struct — three fields: ID, name, price. It's a readonly record structA value type that's both immutable and gets free equality. Two Products with the same Id, Name, and Price are automatically equal. The "readonly" means you can't change any field after creation. Perfect for catalog data., meaning once you create a product, its data is locked. Products are facts — "this laptop costs $999" doesn't change mid-session.
• CartItem class — wraps a Product with a mutable Quantity. Subtotal is a computed property that always returns Price × Quantity — no stored value to get stale.
• ShoppingCart class — holds a private list of CartItems. AddItem() checks if the product is already in the cart (by ID) and increments quantity if so. Total sums all subtotals using LINQLanguage Integrated Query — C#'s built-in toolkit for querying collections. _items.Sum(i => i.Subtotal) iterates through all items and adds up their subtotals in one expressive line. It reads almost like English: "sum of all item subtotals.".
• IReadOnlyList<CartItem> — exposes items for reading (the UI needs to display them) but prevents outside code from directly adding/removing. This is encapsulationHiding internal data and exposing only what's needed. The cart's internal List is private — outsiders get a read-only view. This means nobody can accidentally add an item without going through AddItem(), which handles the "increment quantity if already exists" logic. in action — the cart controls its own collection.

Under 40 lines, and it works for a basic store. But can you spot what's missing? There's no concept of product types (physical vs. digital), no discounts, no bundles, and no notifications. We'll feel each of these pains in the coming levels.

Your Internal Monologue

"Three product types, each with different data... I could use a big class with nullable fields. decimal? Weight, string? DownloadUrl... but that's ugly. A physical product has a DownloadUrl field set to null. Meaningless. And the compiler won't stop me from reading it."

"What about inheritance? A base Product class with PhysicalProduct : Product... That works, but deep inheritance gets messy fast. And these products are mostly data, not behavior. RecordsC# records are designed for immutable data objects. They auto-generate equality, ToString(), and deconstruction. Each product variant is a data carrier with type-specific fields — exactly what records excel at. are better for data-heavy types."

"Actually, an interface for the shared contract + separate records for each type. IProduct defines Id, Name, Price, TaxRate. Each record carries its own specific fields. Tax rate varies by type — each record returns a different value. That's polymorphismDifferent types responding to the same message in different ways. When you call product.TaxRate, a PhysicalProduct returns 0.10m, a DigitalProduct returns 0.05m. Same property, different answers — the caller doesn't need to know which type it is. at work."

public record Product(
    string Id,
    string Name,
    decimal Price,
    ProductType Type,
    decimal? Weight,         // only for physical
    string? DownloadUrl,     // only for digital
    BillingCycle? Cycle      // only for subscription
);

// Every consumer must check Type before accessing fields:
if (product.Type == ProductType.Physical)
    var shipping = product.Weight!.Value * 0.5m;
// Nullable mess. Compiler won't stop you from reading
// product.DownloadUrl on a physical product.

public abstract class Product
{
    public string Id { get; init; }
    public string Name { get; init; }
    public decimal Price { get; init; }
    public abstract decimal TaxRate { get; }
}

public class PhysicalProduct : Product
{
    public decimal Weight { get; init; }
    public override decimal TaxRate => 0.10m;
}

public class DigitalProduct : Product { ... }

// Works! But: classes are reference types (heap allocated),
// need constructors, don't get free equality/ToString.
// And what if you need PhysicalSubscription later?
// Single inheritance blocks that.

public interface IProduct
{
    string Id { get; }
    string Name { get; }
    decimal Price { get; }
    decimal TaxRate { get; }
}

public record PhysicalProduct(string Id, string Name, decimal Price, decimal Weight)
    : IProduct { public decimal TaxRate => 0.10m; }

public record DigitalProduct(string Id, string Name, decimal Price, string DownloadUrl)
    : IProduct { public decimal TaxRate => 0.05m; }

public record SubscriptionProduct(string Id, string Name, decimal Price, BillingCycle Cycle)
    : IProduct { public decimal TaxRate => 0.00m; }

public enum BillingCycle { Monthly, Yearly }

Here's the complete Level 1 code evolution. The Product record becomes an IProduct interface with three implementations, and CartItem now works with any product type.

/// <summary>
/// The shared contract for ALL product types.
/// Any code that works with products uses this interface —
/// it doesn't know (or care) if it's physical, digital, or subscription.
/// </summary>
public interface IProduct
{
    string Id { get; }
    string Name { get; }
    decimal Price { get; }

    /// Each product type returns its own tax rate.
    /// Physical = 10%, Digital = 5%, Subscription = 0%.
    decimal TaxRate { get; }
}

/// Ships in a box. Needs weight for shipping cost calculation.
public record PhysicalProduct(
    string Id,
    string Name,
    decimal Price,
    decimal Weight          // kg — used for shipping cost
) : IProduct
{
    public decimal TaxRate => 0.10m;   // 10% sales tax
}

/// Instant download — no shipping, lower tax.
public record DigitalProduct(
    string Id,
    string Name,
    decimal Price,
    string DownloadUrl      // link sent after purchase
) : IProduct
{
    public decimal TaxRate => 0.05m;   // 5% digital tax
}

public enum BillingCycle { Monthly, Yearly }

/// Recurring charge — no physical goods, no tax.
public record SubscriptionProduct(
    string Id,
    string Name,
    decimal Price,
    BillingCycle Cycle      // Monthly or Yearly
) : IProduct
{
    public decimal TaxRate => 0.00m;   // Tax-exempt
}

public class CartItem
{
    public IProduct Product { get; }          // was: Product record
    public int Quantity { get; set; }
    public decimal Subtotal => Product.Price * Quantity;
    public decimal Tax => Subtotal * Product.TaxRate;  // NEW: tax per line

    public CartItem(IProduct product, int quantity = 1)
    {
        Product = product;
        Quantity = quantity;
    }
}

Let's walk through the key changes:

• IProduct interface — the shared contract. Any code that works with products depends on this interface, not on a specific product type. The cart doesn't need to know which kind of product it holds.
• Three record types — each carries only the fields relevant to its type. No nullable garbage. PhysicalProduct has Weight; DigitalProduct has DownloadUrl; SubscriptionProduct has Cycle.
• TaxRate property — each record returns a different rate. When you call product.TaxRate, the runtime calls the correct implementation. That's polymorphism — same property name, different behavior depending on the actual type.
• CartItem updated — now holds IProduct instead of the concrete Product record. It also computes a Tax property per line item. Zero changes to ShoppingCart — it still calls item.Subtotal and everything works.

public decimal GetTotal()
{
    var subtotal = _items.Sum(i => i.Subtotal);
    if (discountType == "percentage")
        return subtotal * (1 - percentage);
    else if (discountType == "fixed")
        return subtotal - fixedAmount;
    else if (discountType == "bogo")
        return subtotal - cheapestItemPrice;
    // ... every new promotion: another else-if here
}

Your Internal Monologue

"Multiple discount types... I could add a switch statement in GetTotal(). switch (discountType) with cases for percentage, fixed, BOGO. That works for 3 types. But the product manager wants to add new promotions every month — flash sales, tiered discounts, loyalty rewards. I'd be editing GetTotal() constantly."

"What varies here? The algorithm for computing the discount. What stays the same? The operation: take a list of cart items, return a discount amount. Multiple algorithms, same interface... Wait — that's literally the Strategy patternDefine a family of algorithms, put each in its own class, and make them interchangeable. The client (ShoppingCart) doesn't know which algorithm it's using — it just calls CalculateDiscount() on whatever strategy objects are attached. Adding a new discount type = adding one new class.."

"I didn't try to use Strategy. I just asked 'what varies independently?' and the answer pointed me there. That's the thinking tool — not 'memorize when to use Strategy,' but 'notice when multiple algorithms share an interface.'"

"And the cart should support multiple discounts simultaneously. A 20% holiday sale AND a $10 coupon at the same time. So the cart needs a list of strategies, not just one."

public decimal GetTotal()
{
    var subtotal = _items.Sum(i => i.Subtotal);

    return _discountType switch
    {
        "percentage" => subtotal * (1 - _percentage),
        "fixed"      => subtotal - _fixedAmount,
        "bogo"       => subtotal - GetCheapestItemPrice(),
        _            => subtotal
    };
}
// New discount type? Edit GetTotal(). Again. And again.

public decimal GetTotal()
{
    var subtotal = _items.Sum(i => i.Subtotal);
    var discount = 0m;

    if (_hasPercentageDiscount)
        discount += subtotal * _percentage;
    if (_hasFixedDiscount)
        discount += _fixedAmount;
    if (_hasBogo)
        discount += GetCheapestItemPrice();
    if (_hasLoyaltyDiscount)  // added 3 months later
        discount += _loyaltyPoints * 0.01m;
    // ... growing forever

    return subtotal - discount;
}

public interface IDiscountStrategy
{
    decimal CalculateDiscount(IReadOnlyList<CartItem> items);
    string Description { get; }
}

// Cart applies ALL attached strategies — stacking works naturally
public decimal GetTotal()
{
    var subtotal = _items.Sum(i => i.Subtotal);
    var totalDiscount = _discounts.Sum(d => d.CalculateDiscount(_items));
    return Math.Max(0, subtotal - totalDiscount);
}

// Adding "Spend $100 get $15 off"? ONE new class:
public sealed class ThresholdDiscount : IDiscountStrategy { ... }
// ZERO changes to ShoppingCart, ZERO changes to existing discounts.

Here's the complete Level 2 code. We add IDiscountStrategy and three implementations, then update the cart to hold a list of strategies.

/// <summary>
/// The contract every discount type must follow.
/// One method: "given these cart items, how much should I discount?"
/// One property: a human-readable description for the receipt.
/// </summary>
public interface IDiscountStrategy
{
    /// Calculate the discount amount (NOT the final price — just the savings).
    /// Receives the full item list so complex discounts can inspect quantities,
    /// product types, or totals.
    decimal CalculateDiscount(IReadOnlyList<CartItem> items);

    /// Display name for the receipt (e.g., "20% Holiday Sale")
    string Description { get; }
}

/// "20% off your entire order!"
public sealed class PercentageDiscount : IDiscountStrategy
{
    private readonly decimal _percentage;

    public string Description { get; }

    public PercentageDiscount(decimal percentage, string description = "")
    {
        if (percentage < 0 || percentage > 1)
            throw new ArgumentOutOfRangeException(nameof(percentage),
                "Percentage must be between 0 and 1 (e.g., 0.20 for 20%)");

        _percentage = percentage;
        Description = string.IsNullOrEmpty(description)
            ? $"{percentage:P0} Off"
            : description;
    }

    public decimal CalculateDiscount(IReadOnlyList<CartItem> items)
    {
        var subtotal = items.Sum(i => i.Subtotal);
        return Math.Round(subtotal * _percentage, 2);
    }
}

/// "$10 off your order!"
public sealed class FixedAmountDiscount : IDiscountStrategy
{
    private readonly decimal _amount;

    public string Description { get; }

    public FixedAmountDiscount(decimal amount, string description = "")
    {
        if (amount < 0)
            throw new ArgumentOutOfRangeException(nameof(amount),
                "Discount amount cannot be negative");

        _amount = amount;
        Description = string.IsNullOrEmpty(description)
            ? $"${amount} Off"
            : description;
    }

    public decimal CalculateDiscount(IReadOnlyList<CartItem> items)
    {
        var subtotal = items.Sum(i => i.Subtotal);
        // Don't discount more than the subtotal
        return Math.Min(_amount, subtotal);
    }
}

/// "Buy one, get one free!" on a specific product.
/// If the customer has 2+ of the qualifying product,
/// the cheapest one is free.
public sealed class BuyOneGetOneDiscount : IDiscountStrategy
{
    private readonly string _qualifyingProductId;

    public string Description => "Buy One Get One Free";

    public BuyOneGetOneDiscount(string qualifyingProductId)
    {
        _qualifyingProductId = qualifyingProductId;
    }

    public decimal CalculateDiscount(IReadOnlyList<CartItem> items)
    {
        var qualifying = items
            .FirstOrDefault(i => i.Product.Id == _qualifyingProductId);

        // Need at least 2 to qualify
        if (qualifying is null || qualifying.Quantity < 2)
            return 0m;

        // One free item = one unit's price
        return qualifying.Product.Price;
    }
}

public class ShoppingCart
{
    private readonly List<CartItem> _items = new();
    private readonly List<IDiscountStrategy> _discounts = new();  // NEW

    public IReadOnlyList<CartItem> Items => _items;
    public IReadOnlyList<IDiscountStrategy> Discounts => _discounts;  // NEW

    public decimal Subtotal => _items.Sum(i => i.Subtotal);

    /// Total discount from ALL attached strategies
    public decimal TotalDiscount =>
        _discounts.Sum(d => d.CalculateDiscount(_items));

    /// Final total = subtotal minus discounts (never below zero)
    public decimal Total => Math.Max(0, Subtotal - TotalDiscount);

    public decimal TotalTax => _items.Sum(i => i.Tax);  // from L1

    // --- Item management (unchanged from L0) ---
    public void AddItem(IProduct product, int quantity = 1) { /* ... same as before */ }
    public bool RemoveItem(string productId) { /* ... same as before */ }

    // --- Discount management (NEW) ---
    public void ApplyDiscount(IDiscountStrategy discount)
        => _discounts.Add(discount);

    public void RemoveDiscount(IDiscountStrategy discount)
        => _discounts.Remove(discount);
}

Let's walk through the key pieces:

• IDiscountStrategy — one method (CalculateDiscount) and one property (Description). Every discount type implements this contract. The cart never sees concrete types — just the interface.
• PercentageDiscount — takes a decimal between 0 and 1 (0.20 = 20%). Multiplies the subtotal by the percentage. Input validated in the constructorThe method that runs when you create a new object. By validating input here (percentage must be 0-1, amount must be positive), you guarantee that every PercentageDiscount in your system is valid. It's impossible to create a broken one. This is called "making illegal states unrepresentable." so invalid percentages can't sneak in.
• FixedAmountDiscount — subtracts a flat amount. Uses Math.Min to prevent discounting below the subtotal (a $50 coupon on a $30 order gives $30 off, not $50).
• BuyOneGetOneDiscount — targets a specific product by ID. If the customer has 2+ units, one unit's price is the discount. This shows how strategies can inspect individual items, not just the total. The sealedThe sealed keyword prevents other classes from inheriting from this one. PercentageDiscount does one thing well — there's no reason to subclass it. Sealing also gives the runtime a small performance boost because it can skip virtual dispatch lookups. keyword prevents unnecessary subclassing.
• ShoppingCart updates — holds a list of IDiscountStrategy. TotalDiscount sums all strategies. Total subtracts discounts from subtotal using Math.Max(0, ...) to prevent negative totalsWithout the Math.Max guard, stacking a 50% discount with a $200 flat discount on a $300 cart would give -$50. You'd be paying the customer! The guard ensures the minimum total is always zero — discounts can't exceed the cart value.. ApplyDiscount and RemoveDiscount manage the list. The existing item management code is untouched.

Your inner voice:

"Items and bundles... both have a price. A bundle contains items, but it's also an item from the cart's perspective. It's like files and folders — a folder contains files, but you can treat a folder the same way you treat a file (copy it, move it, delete it)."

"If I make a single item and a bundle share the same interface — say, ICartComponent with GetPrice() — then the cart doesn't care what it's holding. A single item returns its own price. A bundle loops over its children and sums their prices (minus a discount). A mega-bundle does the same thing, and its children can be items OR bundles."

"Wait — that's a tree! And a tree where leaves and branches share the same interface... that's the Composite patternThe Composite pattern lets you compose objects into tree structures to represent part-whole hierarchies. The key idea: a single object and a group of objects implement the same interface. The client code treats them identically — it never has to ask "are you a leaf or a branch?" This is how file systems, UI component trees, and bundle pricing work.! I didn't try to force a pattern — I just followed the tree shape of the data and the pattern appeared."

The Big Idea: Composite Pattern

This is a brand-new pattern — and it shows up everywhere once you learn to see it. Let's build your intuition from the ground up before touching any code.

Think about your computer's file system. You have files (they hold data) and folders (they hold files — or other folders). When you right-click a file and check its size, you get a number. When you right-click a folder and check its size, you get the total size of everything inside — including sub-folders. The folder's "size" is computed by recursively summing its children's sizes.

Here's the elegant part: you interact with files and folders using the exact same actions. You can copy, move, delete, or rename either one. The operating system doesn't force you to learn two separate sets of commands. A folder is just a "thing that contains other things" — and it looks like a thing itself.

That's the Composite patternA structural design pattern that composes objects into tree structures. Single objects ("leaves") and groups of objects ("composites") share the same interface, so client code can treat them uniformly without knowing whether it's dealing with a single element or a collection. in one sentence: a single thing and a group of things share the same interface, so the caller never has to check which one it's talking to.

The File & Folder Analogy

Here's how the file system maps perfectly onto our shopping cart:

Before vs. After: Flat List vs. Tree

Without Composite, the cart sees a flat list and needs special logic for bundles. With Composite, the cart sees a tree and calls GetPrice() on each root element — the tree does the rest.

What Would You Do?

Three developers face the bundle problem. Each has a different instinct. Only one survives the "mega-bundle inside a bundle" test.

// Two different types in the cart
List<object> _items = new(); // mixed bag!

public decimal GetTotal()
{
    decimal total = 0;
    foreach (var item in _items)
    {
        if (item is CartItem ci)
            total += ci.Product.Price * ci.Quantity;
        else if (item is BundleItem bi)
            total += bi.Products.Sum(p => p.Price) - bi.Discount;
        // What about mega-bundles? Another branch...
    }
    return total;
}

public class Bundle : Product
{
    public List<Product> Children { get; } = new();
    public decimal Discount { get; set; }

    // Override Price to compute from children
    public override decimal Price
        => Children.Sum(c => c.Price) - Discount;
}

// But Product has: SKU, Weight, Dimensions...
// A Bundle doesn't HAVE a SKU or Weight by itself
// We're forcing unrelated properties onto bundles

public interface ICartComponent
{
    string Name { get; }
    decimal GetPrice();
    IEnumerable<ICartComponent> GetItems();
}

// The cart doesn't care about types:
foreach (var component in cart.Components)
    total += component.GetPrice(); // uniform!

The Solution

Three pieces work together: an interface that both leaves and branches share, a leaf class for individual items, and a composite class for bundles. The beauty is that the cart code doesn't change at all — it already calls GetPrice(), and that just works.

/// <summary>
/// The component interface: both single items and bundles implement this.
/// The cart holds a list of ICartComponent and never checks the concrete type.
/// </summary>
public interface ICartComponent
{
    string Name { get; }

    /// <summary> Price of this component (leaf = product price, bundle = sum - discount) </summary>
    decimal GetPrice();

    /// <summary>
    /// Flatten the tree: a leaf returns itself, a bundle returns all children recursively.
    /// Useful for "show all individual items in the cart" views.
    /// </summary>
    IEnumerable<ICartComponent> GetItems();
}

/// <summary>
/// A leaf node: wraps a single IProduct.
/// GetPrice() returns the product's price.
/// GetItems() returns just itself — there's nothing nested.
/// </summary>
public sealed class SingleItem : ICartComponent
{
    public IProduct Product { get; }
    public int Quantity { get; set; }

    public SingleItem(IProduct product, int quantity = 1)
    {
        Product = product ?? throw new ArgumentNullException(nameof(product));
        Quantity = quantity;
    }

    public string Name => Product.Name;

    // Leaf: just return my own price times quantity
    public decimal GetPrice() => Product.Price * Quantity;

    // Leaf: I'm the only item, so return myself
    public IEnumerable<ICartComponent> GetItems() => [this];
}

/// <summary>
/// A composite node: holds children that are themselves ICartComponent.
/// Children can be SingleItems OR other ProductBundles — nesting is unlimited.
/// </summary>
public sealed class ProductBundle : ICartComponent
{
    private readonly List<ICartComponent> _children = new();

    public string Name { get; }
    public decimal BundleDiscount { get; }

    public ProductBundle(string name, decimal bundleDiscount = 0m)
    {
        Name = name;
        BundleDiscount = bundleDiscount;
    }

    /// <summary> Add an item or another bundle to this bundle. </summary>
    public void Add(ICartComponent component)
        => _children.Add(component);

    /// <summary>
    /// Price = sum of all children's prices minus the bundle discount.
    /// Because children can be bundles too, this call is RECURSIVE:
    /// bundle.GetPrice() calls child-bundle.GetPrice() which calls its children...
    /// The tree walks itself!
    /// </summary>
    public decimal GetPrice()
        => _children.Sum(c => c.GetPrice()) - BundleDiscount;

    /// <summary>
    /// Flatten: ask each child to flatten itself, then merge all results.
    /// SelectMany concatenates: [laptop] + [mouse, bag] = [laptop, mouse, bag]
    /// </summary>
    public IEnumerable<ICartComponent> GetItems()
        => _children.SelectMany(c => c.GetItems());

    public IReadOnlyList<ICartComponent> Children => _children;
}

// Build some individual items
var laptop = new SingleItem(new PhysicalProduct("Laptop", 999m));
var mouse  = new SingleItem(new PhysicalProduct("Mouse", 29m));
var bag    = new SingleItem(new PhysicalProduct("Laptop Bag", 49m));
var monitor = new SingleItem(new PhysicalProduct("Monitor", 299m));
var keyboard = new SingleItem(new PhysicalProduct("Keyboard", 79m));

// Build "Back to School" bundle: laptop + mouse + bag, $50 off
var backToSchool = new ProductBundle("Back to School", bundleDiscount: 50m);
backToSchool.Add(laptop);
backToSchool.Add(mouse);
backToSchool.Add(bag);
// Price: (999 + 29 + 49) - 50 = $1,027

// Build "Ultimate Setup" MEGA-bundle: BackToSchool + monitor + keyboard, $30 off
var ultimateSetup = new ProductBundle("Ultimate Setup", bundleDiscount: 30m);
ultimateSetup.Add(backToSchool);  // a bundle INSIDE a bundle!
ultimateSetup.Add(monitor);
ultimateSetup.Add(keyboard);
// Price: (1027 + 299 + 79) - 30 = $1,375

// The cart doesn't care what it holds:
cart.Add(ultimateSetup);       // bundle of bundles
cart.Add(new SingleItem(new PhysicalProduct("USB Cable", 12m)));

// GetTotal() just calls GetPrice() on each component. Done.
var total = cart.GetTotal(); // $1,375 + $12 = $1,387

How GetPrice() Walks the Tree

When you call GetPrice() on the "Ultimate Setup" mega-bundle, here's what happens behind the scenes. The call bounces down the tree, collects prices at each leaf, and bubbles the sum back up. No loops in your code — the tree structure IS the loop.

Notice how nobody orchestrates this recursion. We didn't write a recursive function. We just called GetPrice() on the top bundle, and because each bundle's GetPrice() calls its children's GetPrice(), the tree walks itself all the way down to the leaves and sums its way back up. That's the power of the Composite pattern — the structure IS the algorithm.

The Composite Tree for Our Shopping Cart

Here's what the cart looks like as a tree structure. The cart itself holds root-level components. Some are leaves (single items), some are branches (bundles) that contain more branches and leaves.

Growing Diagram — Level 3

Two new types join our system: SingleItem (wraps a product as a leaf) and ProductBundle (holds children as a branch). Both implement ICartComponent, so the cart just holds components and never checks concrete types.

Before / After Your Brain

Your inner voice:

"The cart needs to know when prices change. I could have the cart check the catalog every time GetTotal() is called... but that's coupling the cart to the catalog's internal structure. And what about stock changes? Coupon expiry? The cart can't poll everything."

"Flip it around. Instead of the cart asking, the catalog should tell. 'Hey, price changed for product #42.' The cart just listens. And not just the cart — the UI, analytics, email service all want to know too."

"That's the Observer patternThe Observer pattern creates a one-to-many relationship: when one object (the subject/publisher) changes state, all its dependents (observers/subscribers) get notified automatically. Think of it like subscribing to a YouTube channel — when a new video is uploaded, every subscriber gets a notification. The channel doesn't know or care who's subscribed.. The catalog is the publisher, carts and UI components are subscribers. When something changes, the publisher fires an event, and every subscriber reacts in its own way. The publisher doesn't know or care who's listening."

How Events Flow: Publisher → Subscribers

The catalog service acts as the publisherIn the Observer pattern, the publisher (also called "subject") is the object that detects a change and broadcasts a notification. It maintains a list of subscribers but doesn't know what they do with the notification. Think of a radio station — it broadcasts to everyone tuned in, without knowing who's listening.. When a price changes, it broadcasts to every subscriberA subscriber (also called "observer") registers interest in a publisher's events. When the publisher fires an event, every subscriber's callback runs automatically. Each subscriber can react differently — one updates the UI, another logs to analytics, another sends an email. that registered interest. The cart, the UI, and the analytics service all hear about it — but the catalog doesn't know or care who they are.

What Would You Do?

Two approaches to keeping the cart in sync with the outside world. One requires the cart to keep asking. The other lets the world tell the cart.

public decimal GetTotal()
{
    decimal total = 0;
    foreach (var item in _components)
    {
        // Re-fetch CURRENT price every time
        var currentPrice = _catalog.GetCurrentPrice(item.ProductId);
        total += currentPrice * item.Quantity;

        // Check stock too while we're at it
        if (_inventory.GetStock(item.ProductId) == 0)
            item.MarkOutOfStock();
    }
    return _discount?.Apply(total) ?? total;
}

// Cart subscribes to catalog events:
catalogService.PriceChanged += OnPriceChanged;
catalogService.StockDepleted += OnStockDepleted;
couponService.CouponExpired += OnCouponExpired;

// When a price changes, the cart reacts:
private void OnPriceChanged(string productId, decimal newPrice)
{
    var item = FindItem(productId);
    if (item is not null)
    {
        item.UpdatePrice(newPrice);
        NotifyObservers(); // tell UI, analytics, etc.
    }
}

The Solution

We define an ICartObserver interface for anything that wants to hear about cart changes. The cart itself becomes both a subscriber (it listens to catalog events) and a publisher (it notifies UI/analytics when its state changes). This dual role is common in real systems — events cascade through layers.

/// <summary>
/// Any component that wants to react to cart changes implements this.
/// The cart holds a list of ICartObserver and calls the relevant method
/// whenever something happens. The cart doesn't know the concrete types.
/// </summary>
public interface ICartObserver
{
    /// <summary> A product's price changed while it was in the cart </summary>
    void OnItemPriceChanged(string productId, decimal oldPrice, decimal newPrice);

    /// <summary> A product in the cart just went out of stock </summary>
    void OnItemOutOfStock(string productId);

    /// <summary> A discount code applied to the cart has expired </summary>
    void OnDiscountExpired(string discountCode);

    /// <summary> The cart's total changed (for any reason) </summary>
    void OnCartTotalChanged(decimal newTotal);
}

/// <summary>
/// Immutable records carrying event data.
/// Records are perfect for events: they're created once, never modified,
/// and automatically get equality + ToString for free.
/// </summary>
public sealed record PriceChangedEvent(
    string ProductId,
    decimal OldPrice,
    decimal NewPrice,
    DateTimeOffset Timestamp);

public sealed record StockDepletedEvent(
    string ProductId,
    DateTimeOffset Timestamp);

public sealed record CouponExpiredEvent(
    string DiscountCode,
    DateTimeOffset Timestamp);

public sealed class ShoppingCart
{
    private readonly List<ICartComponent> _components = new();
    private readonly List<ICartObserver> _observers = new();

    // --- Observer Management ---
    public void Subscribe(ICartObserver observer)
        => _observers.Add(observer);

    public void Unsubscribe(ICartObserver observer)
        => _observers.Remove(observer);

    // --- Reacting to external events ---
    public void HandlePriceChange(string productId, decimal oldPrice, decimal newPrice)
    {
        // Update the item's price internally
        var item = FindComponentByProductId(productId);
        if (item is SingleItem si)
            si.UpdatePrice(newPrice);

        // Notify all observers: "a price changed!"
        foreach (var obs in _observers)
            obs.OnItemPriceChanged(productId, oldPrice, newPrice);

        // Also notify: "the total changed!"
        NotifyTotalChanged();
    }

    public void HandleStockDepleted(string productId)
    {
        foreach (var obs in _observers)
            obs.OnItemOutOfStock(productId);
    }

    private void NotifyTotalChanged()
    {
        var newTotal = GetTotal();
        foreach (var obs in _observers)
            obs.OnCartTotalChanged(newTotal);
    }
}

Event Flow: Price Change Cascade

Here's what happens when a product's price changes. The event cascades through two layers: first the catalog notifies the cart, then the cart notifies its own subscribers. Each layer is decoupled from the next.

Passive Cart vs. Reactive Cart

Here's the fundamental shift this level introduces. Before Observer, the cart was a calculator that ran on demand. After Observer, the cart is a living component that stays in sync with the world.

Growing Diagram — Level 4

The Observer infrastructure joins our system. ICartObserver is the new interface, and the cart gains Subscribe() / Unsubscribe() methods. Concrete observers implement the interface.

Before / After Your Brain

Your inner voice:

"Let me walk through the 'What If?' framework systematically..."

"Concurrency: Two users, one item left. Both click 'Add.' Without a lock, both succeed, and we've sold something we don't have. That's a race condition. I need atomic 'check + reserve' operations."

"Failure: Stock depletes after adding. Payment fails at checkout. The product gets discontinued. Each needs a clear error path — not just throwing exceptions, but returning a Result typeA Result type wraps either a success value or an error. Instead of throwing exceptions (which are invisible to the caller), you return a Result that forces the caller to handle both cases. In C#, this might be a record like Result<T> with IsSuccess, Value, and ErrorMessage properties. It makes error handling explicit and visible. so the caller MUST handle the failure."

"Boundary: Adding 0 items. Adding negative quantity. Cart with 10,000 items. Empty cart checkout. Each needs validation at the entry point."

"Timing: Coupon expires mid-session. Price changes during checkout. Cart sits idle for 24 hours. These need time-aware validation that runs at checkout, not just at add-time."

The "What If?" Framework

This is your edge-case discovery tool. For every operation, systematically ask these four questions. Senior engineers do this instinctively — it's a learned reflex, not a talent.

What Would You Do?

Two approaches to handling failures. One throws exceptions and hopes someone catches them. The other makes error handling explicit and impossible to ignore.

public void AddItem(IProduct product, int quantity)
{
    if (quantity <= 0)
        throw new ArgumentException("Quantity must be positive");
    if (_inventory.GetStock(product.Id) < quantity)
        throw new OutOfStockException(product.Id);
    // ... add the item
}

// Caller has to remember to catch:
try { cart.AddItem(laptop, 2); }
catch (OutOfStockException ex) { /* handle */ }
catch (ArgumentException ex) { /* handle */ }
// What if they forget? Runtime crash.

public sealed record CartResult
{
    public bool IsSuccess { get; init; }
    public string? Error { get; init; }

    public static CartResult Ok() => new() { IsSuccess = true };
    public static CartResult Fail(string error) => new() { IsSuccess = false, Error = error };
}

public CartResult AddItem(IProduct product, int quantity)
{
    if (quantity <= 0)
        return CartResult.Fail("Quantity must be positive.");
    if (_inventory.GetStock(product.Id) < quantity)
        return CartResult.Fail($"Only {_inventory.GetStock(product.Id)} in stock.");

    // ... add the item
    return CartResult.Ok();
}

// Caller SEES the result type and must handle it:
var result = cart.AddItem(laptop, 2);
if (!result.IsSuccess)
    ShowError(result.Error); // can't forget!

The Solution: Validation Pipeline

Instead of scattering validation checks throughout the cart, we build a validation pipeline. Each operation (add, remove, checkout) passes through a series of validation gates. If any gate fails, the operation stops with a clear error message. Think of it like airport security — you pass through multiple checkpoints, and any one of them can stop you.

public sealed record CartResult
{
    public bool IsSuccess { get; init; }
    public string? Error { get; init; }
    public CartErrorCode Code { get; init; }

    public static CartResult Ok()
        => new() { IsSuccess = true, Code = CartErrorCode.None };

    public static CartResult Fail(string error, CartErrorCode code)
        => new() { IsSuccess = false, Error = error, Code = code };
}

public enum CartErrorCode
{
    None,
    OutOfStock,
    InvalidQuantity,
    CouponExpired,
    CartEmpty,
    StalePrice,
    ConcurrencyConflict
}

public CartResult AddItem(IProduct product, int quantity)
{
    // Gate 1: Input validation
    if (quantity <= 0)
        return CartResult.Fail(
            "Quantity must be at least 1.",
            CartErrorCode.InvalidQuantity);

    // Gate 2: Stock check
    var stock = _inventory.GetStock(product.Id);
    if (stock < quantity)
        return CartResult.Fail(
            $"Only {stock} available (you requested {quantity}).",
            CartErrorCode.OutOfStock);

    // Gate 3: Reserve stock (atomic operation)
    if (!_inventory.TryReserve(product.Id, quantity))
        return CartResult.Fail(
            "Another customer just took the last one!",
            CartErrorCode.ConcurrencyConflict);

    // All gates passed — add to cart
    var item = new SingleItem(product, quantity);
    _components.Add(item);
    NotifyTotalChanged();
    return CartResult.Ok();
}

public CartResult Checkout()
{
    // Gate 1: Not empty
    if (!_components.Any())
        return CartResult.Fail("Cart is empty.", CartErrorCode.CartEmpty);

    // Gate 2: Re-validate all prices (might have changed since add)
    foreach (var item in _components.OfType<SingleItem>())
    {
        var currentPrice = _catalog.GetCurrentPrice(item.Product.Id);
        if (currentPrice != item.Product.Price)
            return CartResult.Fail(
                $"Price of {item.Name} changed from {item.Product.Price:C} to {currentPrice:C}. Please review.",
                CartErrorCode.StalePrice);
    }

    // Gate 3: Re-validate all stock (might have depleted)
    foreach (var item in _components.OfType<SingleItem>())
    {
        if (_inventory.GetStock(item.Product.Id) < item.Quantity)
            return CartResult.Fail(
                $"{item.Name} is no longer available in requested quantity.",
                CartErrorCode.OutOfStock);
    }

    // Gate 4: Validate coupon hasn't expired
    if (_discount is not null && _couponService.IsExpired(_discount.Code))
        return CartResult.Fail(
            $"Coupon '{_discount.Code}' has expired.",
            CartErrorCode.CouponExpired);

    // All gates passed — proceed to payment
    return CartResult.Ok();
}

The Race Condition: Two Users, One Item

This is the most dangerous edge case. Without atomic "check + reserve," two users can both add the last item, and you've promised something you can't deliver.

The Validation Pipeline

Every cart operation passes through validation gates. Like airport security: each checkpoint looks for one specific problem. If any gate fails, the operation stops with a clear error.

Growing Diagram — Level 5

CartResult and the validation pipeline join the system. Every public method now returns a result type, and the inventory gains atomic reservation.

Before / After Your Brain

Your inner voice:

"The cart calls _inventory.GetStock(). In a test, I don't have a real inventory. If the cart does new InventoryService() inside itself, I can't replace it with a mock."

"But if the cart receives IInventoryService through its constructor, then in production I pass the real one, and in tests I pass a fake that returns whatever I want. The cart never knows the difference."

"That's Dependency InjectionDependency Injection (DI) means an object receives its dependencies from the outside instead of creating them. The constructor says "I need an IInventoryService" and whoever creates the object decides which implementation to provide. In production, it's the real service. In tests, it's a fake/mock. The object itself never changes.. Don't create your dependencies — receive them. And since the cart depends on interfaces (not concrete classes), any implementation that matches the interface will work. Including test fakes."

The Solution: Dependency Injection + Interface Segregation

The cart receives all its dependencies through the constructor. In production, the DI containerA DI container (also called IoC container) is a framework that automatically creates objects and wires their dependencies together. In .NET, you register interfaces and their implementations (e.g., "when someone asks for IInventoryService, give them WarehouseInventory"), and the container does the rest. No manual new-ing required. provides real services. In tests, you pass lightweight fakes that let you control everything.

public sealed class ShoppingCart
{
    private readonly IInventoryService _inventory;
    private readonly ICatalogService _catalog;
    private readonly ICouponService _coupons;
    private readonly ITimeProvider _time;

    // Dependencies come FROM OUTSIDE — cart doesn't create them
    public ShoppingCart(
        IInventoryService inventory,
        ICatalogService catalog,
        ICouponService coupons,
        ITimeProvider time)
    {
        _inventory = inventory ?? throw new ArgumentNullException(nameof(inventory));
        _catalog = catalog ?? throw new ArgumentNullException(nameof(catalog));
        _coupons = coupons ?? throw new ArgumentNullException(nameof(coupons));
        _time = time ?? throw new ArgumentNullException(nameof(time));
    }

    // Now coupon expiry checks use _time.UtcNow instead of DateTime.UtcNow
    // In tests: set _time to return any date you want!
}

/// <summary>
/// Abstracting time lets you test coupon expiry, cart abandonment,
/// and flash sales without actually waiting. In tests, you control the clock.
/// </summary>
public interface ITimeProvider
{
    DateTimeOffset UtcNow { get; }
}

// Production: uses the real system clock
public sealed class SystemTimeProvider : ITimeProvider
{
    public DateTimeOffset UtcNow => DateTimeOffset.UtcNow;
}

// Tests: you control what "now" means
public sealed class FakeTimeProvider : ITimeProvider
{
    public DateTimeOffset UtcNow { get; set; } = DateTimeOffset.UtcNow;

    public void AdvanceBy(TimeSpan duration)
        => UtcNow = UtcNow.Add(duration);
}

[Fact]
public void AddItem_WhenOutOfStock_ReturnsFailure()
{
    // Arrange: fake inventory that says "0 in stock"
    var fakeInventory = new FakeInventory(stock: 0);
    var cart = new ShoppingCart(fakeInventory, fakeCatalog, fakeCoupons, fakeTime);

    // Act
    var result = cart.AddItem(laptop, quantity: 1);

    // Assert
    Assert.False(result.IsSuccess);
    Assert.Equal(CartErrorCode.OutOfStock, result.Code);
}

[Fact]
public void Checkout_WhenCouponExpired_ReturnsFailure()
{
    // Arrange: coupon valid NOW, but checkout happens LATER
    var fakeTime = new FakeTimeProvider();
    var cart = new ShoppingCart(fakeInv, fakeCat, fakeCoupons, fakeTime);
    cart.AddItem(laptop, 1);
    cart.ApplyCoupon("SAVE20"); // valid at this moment

    // Act: fast-forward 25 hours
    fakeTime.AdvanceBy(TimeSpan.FromHours(25));
    var result = cart.Checkout();

    // Assert: coupon expired!
    Assert.False(result.IsSuccess);
    Assert.Equal(CartErrorCode.CouponExpired, result.Code);
}

[Fact]
public void GetTotal_WithBundleDiscount_CalculatesCorrectly()
{
    var cart = new ShoppingCart(fakeInv, fakeCat, fakeCoupons, fakeTime);
    var bundle = new ProductBundle("Test Bundle", bundleDiscount: 50m);
    bundle.Add(new SingleItem(new FakeProduct("A", 100m)));
    bundle.Add(new SingleItem(new FakeProduct("B", 200m)));

    cart.Add(bundle);

    Assert.Equal(250m, cart.GetTotal()); // (100+200) - 50
}

DI Wiring: Production vs. Test

Test Isolation: Each Test Controls One Variable

Growing Diagram — Level 6

Before / After Your Brain

Your inner voice:

"Single server, single process — that's all my LLD assumed. Now I need multiple sellers with their own inventory, cross-device sync, and millions of carts. Let me think..."

"Multi-seller: Each seller is essentially their own 'store' with their own IInventoryService and pricing. The cart holds items from multiple sellers. At checkout, I split the order by seller. That's the marketplace patternIn a marketplace architecture, the platform (e.g., Amazon) hosts many sellers. Each seller manages their own inventory and pricing. A single customer cart can contain items from multiple sellers. At checkout, the order is split into sub-orders per seller, each processed independently. This is why Amazon packages arrive from different warehouses on different days.."

"Cross-device sync: The cart can't live only in memory — it needs persistent storage (Redis or a database). When the phone adds an item, an event fires, and the laptop's cart polls or listens for changes."

"Millions of carts: One database can't handle all writes. I'd shard carts by user ID — user 12345 always goes to shard 3. Or use an event-driven architecture where cart operations become events in a message queue. This is where my Observer pattern knowledge directly transfers to distributed systems!"

The Marketplace Architecture

In a marketplace, the platform hosts many sellers. Each seller manages their own products and inventory. A customer's cart pulls from multiple sellers, and at checkout, the order splits by seller — each handled independently. This is why your Amazon order often arrives in multiple packages from different warehouses.

Cross-Device Sync: Your Cart Follows You

The cart needs persistent storage so it's the same on every device. When you add an item on your phone, your laptop sees it instantly. This is where your Observer pattern knowledge transfers directly to distributed systems — events over a network instead of events within a process.

Growing Diagram — Level 7 (Final Architecture)

Notice the key insight: your LLD patterns don't change when you scale. The Composite pattern still computes bundle prices. Strategy still swaps discount algorithms. Observer still notifies listeners. What changes is the infrastructure around them: in-memory lists become Redis, method calls become API calls, and event handlers become message queue subscribers. Clean LLD is the foundation that makes HLD possible.

Before / After Your Brain

You've built this shopping cart piece by piece across seven levels. Now it's time to see the whole thing in one place. Every file below is the final, production-ready version — incorporating every pattern and refinement we discovered along the way.

Before we dive into the code, here's a bird's-eye view of every type in the system, color-coded by the level that introduced it. Green types appeared early (Levels 0–1), yellow ones came in the middle (Levels 2–4), and red ones were added in the advanced levels (5–7). Notice how the system grew organically — each type was forced into existence by a real constraint, not by upfront planning.

Now let's see the actual code. Each file is organized by responsibility — models in one place, discount strategies in another, composite components in a third. Click through the tabs to read each file.

namespace ShoppingCart.Models;

// ─── IProduct ────────────────────────────────────────
// The contract every product must follow.                // Level 1
// Physical goods, digital downloads, and subscriptions
// all look the same to the cart — it only cares about
// name, price, and whether the item needs shipping.
public interface IProduct
{
    string Name { get; }
    decimal Price { get; }
    bool RequiresShipping { get; }
    int StockCount { get; }
}

// ─── PhysicalProduct ────────────────────────────────
// Things you can hold: books, shoes, cables.             // Level 1
// They need shipping and have limited stock.
public record PhysicalProduct(
    string Name,
    decimal Price,
    double WeightKg,
    int StockCount
) : IProduct
{
    public bool RequiresShipping => true;
}

// ─── DigitalProduct ─────────────────────────────────
// Things you download: ebooks, music, software.          // Level 1
// No shipping needed. Stock is effectively infinite.
public record DigitalProduct(
    string Name,
    decimal Price
) : IProduct
{
    public bool RequiresShipping => false;
    public int StockCount => int.MaxValue; // Level 5 — always in stock
}

// ─── SubscriptionProduct ────────────────────────────
// Recurring services: monthly plans, yearly passes.      // Level 1
// Has a billing cycle and renewal date.
public record SubscriptionProduct(
    string Name,
    decimal Price,
    string BillingCycle  // "monthly" | "yearly"
) : IProduct
{
    public bool RequiresShipping => false;
    public int StockCount => int.MaxValue;
}

// ─── CartItem ───────────────────────────────────────
// Pairs a product with a quantity. This is what            // Level 0
// actually lives inside the cart.
public class CartItem
{
    public IProduct Product { get; }                       // Level 1 — was concrete Product
    public int Quantity { get; private set; }

    public CartItem(IProduct product, int quantity = 1)
    {
        Product = product ?? throw new ArgumentNullException(nameof(product));
        Quantity = quantity > 0 ? quantity
            : throw new ArgumentOutOfRangeException(nameof(quantity));  // Level 5
    }

    public decimal Subtotal => Product.Price * Quantity;

    public void IncreaseQuantity(int amount = 1)
    {
        if (amount <= 0)
            throw new ArgumentOutOfRangeException(nameof(amount)); // Level 5
        Quantity += amount;
    }

    public void DecreaseQuantity(int amount = 1)
    {
        if (amount <= 0 || amount > Quantity)
            throw new ArgumentOutOfRangeException(nameof(amount)); // Level 5
        Quantity -= amount;
    }
}

// ─── CartResult<T> ──────────────────────────────────
// A generic result wrapper — either a value or an error.  // Level 5
// Used for operations that might fail (out of stock,
// expired coupon, concurrent modification).
public record CartResult<T>(T? Value, string? Error = null)
{
    public bool IsSuccess => Error is null;
    public static CartResult<T> Ok(T value) => new(value);
    public static CartResult<T> Fail(string error) => new(default, error);
}

namespace ShoppingCart.Discounts;

// ─── The contract for calculating discounts ──────────
// Any discount — percentage off, fixed amount, BOGO —     // Level 2
// implements this one method. The cart doesn't care
// HOW the discount is calculated, only that it gets
// a dollar amount back.
public interface IDiscountStrategy
{
    string Name { get; }
    decimal CalculateDiscount(IReadOnlyList<CartItem> items);
    bool IsExpired(DateTime now);                           // Level 5
}

// ─── PercentageDiscount ─────────────────────────────
// "20% off your entire cart." The most common type.       // Level 2
public sealed class PercentageDiscount : IDiscountStrategy
{
    private readonly decimal _percentage;
    private readonly DateTime? _expiresAt;                  // Level 5

    public string Name { get; }

    public PercentageDiscount(string name, decimal percentage, DateTime? expiresAt = null)
    {
        if (percentage <= 0 || percentage > 100)
            throw new ArgumentOutOfRangeException(nameof(percentage));
        Name = name;
        _percentage = percentage;
        _expiresAt = expiresAt;
    }

    public decimal CalculateDiscount(IReadOnlyList<CartItem> items)
    {
        var subtotal = items.Sum(i => i.Subtotal);
        return Math.Round(subtotal * _percentage / 100m, 2);
    }

    public bool IsExpired(DateTime now) =>
        _expiresAt.HasValue && now > _expiresAt.Value;      // Level 5
}

// ─── FixedAmountDiscount ────────────────────────────
// "$10 off your order." Simple, predictable.              // Level 2
public sealed class FixedAmountDiscount : IDiscountStrategy
{
    private readonly decimal _amount;
    private readonly decimal _minimumOrder;                  // Level 5
    private readonly DateTime? _expiresAt;

    public string Name { get; }

    public FixedAmountDiscount(string name, decimal amount,
        decimal minimumOrder = 0m, DateTime? expiresAt = null)
    {
        _amount = amount > 0 ? amount
            : throw new ArgumentOutOfRangeException(nameof(amount));
        _minimumOrder = minimumOrder;
        _expiresAt = expiresAt;
        Name = name;
    }

    public decimal CalculateDiscount(IReadOnlyList<CartItem> items)
    {
        var subtotal = items.Sum(i => i.Subtotal);
        if (subtotal < _minimumOrder) return 0m;            // Level 5
        return Math.Min(_amount, subtotal);  // Never discount more than total
    }

    public bool IsExpired(DateTime now) =>
        _expiresAt.HasValue && now > _expiresAt.Value;
}

// ─── BuyOneGetOneDiscount ───────────────────────────
// "Buy 2 of the same item, get the cheapest free."        // Level 2
// The trickiest discount — it needs to look at
// individual items, not just the cart total.
public sealed class BuyOneGetOneDiscount : IDiscountStrategy
{
    private readonly string _targetProductName;
    private readonly DateTime? _expiresAt;

    public string Name => $"BOGO on {_targetProductName}";

    public BuyOneGetOneDiscount(string targetProductName, DateTime? expiresAt = null)
    {
        _targetProductName = targetProductName;
        _expiresAt = expiresAt;
    }

    public decimal CalculateDiscount(IReadOnlyList<CartItem> items)
    {
        // Find the matching item
        var target = items.FirstOrDefault(
            i => i.Product.Name == _targetProductName);
        if (target is null || target.Quantity < 2) return 0m;

        // Every second item is free
        int freeItems = target.Quantity / 2;
        return freeItems * target.Product.Price;
    }

    public bool IsExpired(DateTime now) =>
        _expiresAt.HasValue && now > _expiresAt.Value;
}

namespace ShoppingCart.Components;

// ─── ICartComponent ─────────────────────────────────
// The Composite contract. Both individual items AND        // Level 3
// bundles of items implement this. The cart can hold
// a mix of singles and bundles without caring which
// is which — it just asks "what's your price?"
public interface ICartComponent
{
    string DisplayName { get; }
    decimal GetPrice();
    int GetItemCount();
    IEnumerable<ICartComponent> GetChildren();               // Level 3
}

// ─── SingleItem ─────────────────────────────────────
// A leaf node: one product with a quantity.                // Level 3
// This is the simplest component in the tree.
public sealed class SingleItem : ICartComponent
{
    private readonly CartItem _item;

    public SingleItem(CartItem item)
    {
        _item = item ?? throw new ArgumentNullException(nameof(item));
    }

    public string DisplayName =>
        $"{_item.Product.Name} x{_item.Quantity}";
    public decimal GetPrice() => _item.Subtotal;
    public int GetItemCount() => _item.Quantity;
    public IEnumerable<ICartComponent> GetChildren() =>
        Enumerable.Empty<ICartComponent>();                  // Leaf — no children
}

// ─── ProductBundle ──────────────────────────────────
// A composite node: a named group of items (or other       // Level 3
// bundles!) sold together at a bundle price.
// Example: "Gaming Starter Pack" = keyboard + mouse + pad
public sealed class ProductBundle : ICartComponent
{
    private readonly List<ICartComponent> _children = [];
    private readonly decimal _bundleDiscount;                 // Level 3

    public string DisplayName { get; }

    public ProductBundle(string name, decimal bundleDiscountPercent = 0m)
    {
        DisplayName = name;
        _bundleDiscount = bundleDiscountPercent;
    }

    // Add a single item or another bundle — tree structure!
    public void Add(ICartComponent component)
    {
        // Level 5: prevent circular references
        if (component == this)
            throw new InvalidOperationException("A bundle cannot contain itself.");
        if (component is ProductBundle bundle && ContainsRecursive(bundle, this))
            throw new InvalidOperationException("Circular bundle reference detected.");

        _children.Add(component);
    }

    public decimal GetPrice()
    {
        var rawTotal = _children.Sum(c => c.GetPrice());
        var discount = rawTotal * _bundleDiscount / 100m;
        return Math.Round(rawTotal - discount, 2);
    }

    public int GetItemCount() => _children.Sum(c => c.GetItemCount());

    public IEnumerable<ICartComponent> GetChildren() => _children;

    // Recursive check to prevent bundle-contains-itself loops  // Level 5
    private static bool ContainsRecursive(ProductBundle needle, ICartComponent haystack)
    {
        foreach (var child in haystack.GetChildren())
        {
            if (child == needle) return true;
            if (child is ProductBundle pb && ContainsRecursive(needle, pb))
                return true;
        }
        return false;
    }
}

namespace ShoppingCart;

// ─── ICartObserver ──────────────────────────────────
// Observers get notified when things happen in the cart.   // Level 4
// Price drops, stock alerts, coupon events — any
// listener can subscribe without the cart knowing
// what they do with the information.
public interface ICartObserver
{
    void OnItemAdded(CartItem item);
    void OnItemRemoved(string productName);
    void OnPriceChanged(string productName, decimal oldPrice, decimal newPrice);
    void OnCartCleared();
}

// ─── ShoppingCart ───────────────────────────────────
// The orchestrator. Manages items, applies discounts,      // Level 0
// notifies observers, and handles concurrent access.
public sealed class ShoppingCart
{
    private readonly List<ICartComponent> _components = []; // Level 3 — was List<CartItem>
    private readonly List<IDiscountStrategy> _discounts = [];// Level 2
    private readonly List<ICartObserver> _observers = [];    // Level 4
    private readonly object _lock = new();                   // Level 5
    private readonly IPricingService _pricingService;        // Level 6
    private readonly IInventoryService _inventoryService;    // Level 6
    private readonly ITimeProvider _timeProvider;             // Level 6

    public ShoppingCart(
        IPricingService pricingService,
        IInventoryService inventoryService,
        ITimeProvider timeProvider)                           // Level 6 — DI
    {
        _pricingService = pricingService;
        _inventoryService = inventoryService;
        _timeProvider = timeProvider;
    }

    // ─ Observer management ─                               // Level 4
    public void Subscribe(ICartObserver observer) =>
        _observers.Add(observer);
    public void Unsubscribe(ICartObserver observer) =>
        _observers.Remove(observer);
    private void NotifyItemAdded(CartItem item) =>
        _observers.ForEach(o => o.OnItemAdded(item));
    private void NotifyItemRemoved(string name) =>
        _observers.ForEach(o => o.OnItemRemoved(name));

    // ─ Add an item ─
    public CartResult<CartItem> AddItem(IProduct product, int quantity = 1)
    {
        lock (_lock)                                          // Level 5
        {
            // Validate stock
            if (!_inventoryService.IsInStock(product.Name, quantity)) // Level 6
                return CartResult<CartItem>.Fail(
                    $"Not enough stock for {product.Name}.");

            // Check if item already in cart (as SingleItem)
            var existing = FindExistingSingleItem(product.Name);
            if (existing is not null)
            {
                existing.IncreaseQuantity(quantity);
                return CartResult<CartItem>.Ok(existing);
            }

            // Add new item
            var cartItem = new CartItem(product, quantity);
            _components.Add(new SingleItem(cartItem));
            NotifyItemAdded(cartItem);
            return CartResult<CartItem>.Ok(cartItem);
        }
    }

    // ─ Add a bundle ─                                       // Level 3
    public CartResult<ProductBundle> AddBundle(ProductBundle bundle)
    {
        lock (_lock)
        {
            _components.Add(bundle);
            return CartResult<ProductBundle>.Ok(bundle);
        }
    }

    // ─ Remove an item by product name ─
    public CartResult<bool> RemoveItem(string productName)
    {
        lock (_lock)
        {
            var component = _components.FirstOrDefault(c =>
                c.DisplayName.StartsWith(productName));
            if (component is null)
                return CartResult<bool>.Fail($"'{productName}' not found in cart.");

            _components.Remove(component);
            NotifyItemRemoved(productName);
            return CartResult<bool>.Ok(true);
        }
    }

    // ─ Apply a discount ─                                    // Level 2
    public CartResult<bool> ApplyDiscount(IDiscountStrategy discount)
    {
        if (discount.IsExpired(_timeProvider.UtcNow))          // Level 5 + Level 6
            return CartResult<bool>.Fail(
                $"Discount '{discount.Name}' has expired.");

        _discounts.Add(discount);
        return CartResult<bool>.Ok(true);
    }

    // ─ Calculate the final total ─
    public decimal CalculateTotal()
    {
        lock (_lock)
        {
            var subtotal = _components.Sum(c => c.GetPrice());
            var now = _timeProvider.UtcNow;                    // Level 6

            // Remove expired discounts, then calculate            // Level 5
            _discounts.RemoveAll(d => d.IsExpired(now));

            var totalDiscount = _discounts.Sum(d =>
                d.CalculateDiscount(GetFlatItems()));

            var finalTotal = subtotal - totalDiscount;
            return Math.Max(0m, Math.Round(finalTotal, 2));    // Never go negative
        }
    }

    // ─ Flatten the component tree into CartItems ─           // Level 3
    private IReadOnlyList<CartItem> GetFlatItems()
    {
        var flat = new List<CartItem>();
        FlattenRecursive(_components, flat);
        return flat;
    }

    private static void FlattenRecursive(
        IEnumerable<ICartComponent> components, List<CartItem> result)
    {
        foreach (var c in components)
        {
            if (c is SingleItem si)
                result.Add(GetCartItemFromSingle(si));
            else
                FlattenRecursive(c.GetChildren(), result);
        }
    }

    // ─ Helpers ─
    private CartItem? FindExistingSingleItem(string productName) =>
        _components.OfType<SingleItem>()
            .Select(si => GetCartItemFromSingle(si))
            .FirstOrDefault(ci => ci.Product.Name == productName);

    private static CartItem GetCartItemFromSingle(SingleItem si)
    {
        // Uses reflection-free access via the DisplayName pattern
        // In production, you'd expose CartItem directly on SingleItem
        var field = typeof(SingleItem)
            .GetField("_item", System.Reflection.BindingFlags.NonPublic
                | System.Reflection.BindingFlags.Instance);
        return (CartItem)field!.GetValue(si)!;
    }

    public IReadOnlyList<ICartComponent> Components => _components;
    public int TotalItemCount => _components.Sum(c => c.GetItemCount());

    public void Clear()
    {
        lock (_lock)
        {
            _components.Clear();
            _discounts.Clear();
            _observers.ForEach(o => o.OnCartCleared());
        }
    }
}

using Microsoft.Extensions.DependencyInjection;
using ShoppingCart;
using ShoppingCart.Models;
using ShoppingCart.Discounts;
using ShoppingCart.Components;

// ─── Service interfaces ─────────────────────────────
public interface IPricingService                              // Level 6
{
    decimal GetCurrentPrice(string productName);
}

public interface IInventoryService                            // Level 6
{
    bool IsInStock(string productName, int quantity);
    void Reserve(string productName, int quantity);
}

public interface ITimeProvider                                 // Level 6
{
    DateTime UtcNow { get; }
}

// ─── Default implementations ────────────────────────
public class DefaultPricingService : IPricingService
{
    public decimal GetCurrentPrice(string name) => 0m; // Placeholder
}

public class DefaultInventoryService : IInventoryService
{
    public bool IsInStock(string name, int qty) => true;
    public void Reserve(string name, int qty) { }
}

public class SystemTimeProvider : ITimeProvider               // Level 6
{
    public DateTime UtcNow => DateTime.UtcNow;
}

// ─── Sample observers ───────────────────────────────
public class PriceDropAlert : ICartObserver                   // Level 4
{
    public void OnItemAdded(CartItem item) =>
        Console.WriteLine($"  [Alert] Watching '{item.Product.Name}' for price drops.");
    public void OnItemRemoved(string name) =>
        Console.WriteLine($"  [Alert] Stopped watching '{name}'.");
    public void OnPriceChanged(string name, decimal oldP, decimal newP) =>
        Console.WriteLine($"  [Alert] '{name}' price changed: {oldP:C} → {newP:C}!");
    public void OnCartCleared() =>
        Console.WriteLine("  [Alert] Cart cleared — all watches removed.");
}

// ─── Wire up DI ─────────────────────────────────────
var services = new ServiceCollection();
services.AddSingleton<IPricingService, DefaultPricingService>();
services.AddSingleton<IInventoryService, DefaultInventoryService>();
services.AddSingleton<ITimeProvider, SystemTimeProvider>();
var provider = services.BuildServiceProvider();

// ─── Build the cart ─────────────────────────────────
var cart = new ShoppingCart.ShoppingCart(
    provider.GetRequiredService<IPricingService>(),
    provider.GetRequiredService<IInventoryService>(),
    provider.GetRequiredService<ITimeProvider>());

// Subscribe an observer
cart.Subscribe(new PriceDropAlert());

// ─── Add some products ──────────────────────────────
var book = new PhysicalProduct("Clean Code", 39.99m, 0.45, 100);
var ebook = new DigitalProduct("Design Patterns PDF", 29.99m);
var netflix = new SubscriptionProduct("Streaming Plan", 14.99m, "monthly");

cart.AddItem(book, 2);
cart.AddItem(ebook);
cart.AddItem(netflix);

// ─── Create a bundle ────────────────────────────────
var bundle = new ProductBundle("Dev Starter Pack", bundleDiscountPercent: 15);
bundle.Add(new SingleItem(new CartItem(
    new PhysicalProduct("Mechanical Keyboard", 79.99m, 0.8, 50))));
bundle.Add(new SingleItem(new CartItem(
    new PhysicalProduct("Mouse Pad XL", 19.99m, 0.3, 200))));
cart.AddBundle(bundle);

// ─── Apply a discount ───────────────────────────────
cart.ApplyDiscount(new PercentageDiscount(
    "SUMMER20", 20, expiresAt: DateTime.UtcNow.AddDays(30)));

// ─── Print summary ──────────────────────────────────
Console.WriteLine($"\n🛒 Cart: {cart.TotalItemCount} items");
foreach (var component in cart.Components)
    Console.WriteLine($"  • {component.DisplayName} — {component.GetPrice():C}");

Console.WriteLine($"\n💰 Total after discounts: {cart.CalculateTotal():C}");
Console.WriteLine("Done!");

You've been using design patterns for the last seven levels. But here's the interesting part: you might not have noticed all of them. Some patterns are obvious — we named them as we built them. Others are hiding in the code, doing their job quietly without anyone putting a label on them.

This section is about developing pattern recognitionThe ability to look at code and see the underlying design patterns at work. Senior engineers do this unconsciously — they glance at code and immediately see "that's a Strategy" or "that's a Composite." This skill comes from practice: once you've built patterns yourself, you spot them everywhere. — the skill of looking at code and seeing the structural bones underneath. Let's start with a challenge.

The Four Explicit Patterns

These are the patterns we named during the build. For each one, let's look at where it lives in the code, what it enables, and what would happen without it.

How Patterns Interact at Runtime

Patterns don't work in isolation. When a customer adds an item and checks out, multiple patterns fire in sequence. Here's the interaction flow:

This is the visual summary of the entire Constraint Game. Watch the system grow from a single class to a 24-type architecture, one level at a time. Each stage adds exactly the types that were forced into existence by that level's constraint.

Entity Summary Table

Here's every type in the system, what kind of type it is, which level introduced it, and why it's that kind of type. This table is your study guide for the entire Shopping Cart architecture.

You've seen the good solution — built incrementally over 7 levels. Now let's study five bad approaches that people commonly reach for. Each one is tempting for a different reason, and each one breaks in a different way. We'll walk through the exact code, show you an SVG of the problem, and demonstrate the fix.

public class ShoppingCartSystem
{
    private List<(string name, decimal price, int qty)> items = new();
    private string discountType = "none";
    private decimal discountValue = 0;

    public void AddItem(string name, decimal price, int qty)
    {
        items.Add((name, price, qty));
        Console.WriteLine($"Added {name}");          // UI coupled to logic
        SendEmail($"Item added: {name}");             // Email in the cart?!
        UpdateAnalytics("item_added", name);          // Analytics too?!
    }

    public decimal CalculateTotal()
    {
        decimal total = items.Sum(i => i.price * i.qty);
        // Discount logic inline — grows with every new type
        if (discountType == "percent")
            total -= total * discountValue / 100;
        else if (discountType == "fixed")
            total -= discountValue;
        else if (discountType == "bogo")
        {
            // 50 lines of BOGO logic...
        }
        return total;
    }

    private void SendEmail(string msg) { /* SMTP code here */ }
    private void UpdateAnalytics(string evt, string data) { /* HTTP call */ }
    // ... 800 more lines of mixed concerns
}

// To add an item to the cart, you need:
public interface ICartItemFactory { CartItem Create(IProduct product); }
public interface ICartItemBuilder { ICartItemBuilder WithQuantity(int q); CartItem Build(); }
public interface ICartCommandHandler { void Handle(ICartCommand cmd); }
public interface ICartCommand { }
public record AddItemCommand(IProduct Product) : ICartCommand;
public interface ICartEventMediator { void Publish(ICartEvent e); }
public interface ICartEvent { }
public record ItemAddedEvent(CartItem Item) : ICartEvent;
public interface ICartRepository { void Save(ShoppingCart cart); }
public interface ICartUnitOfWork { void Commit(); }

// And the actual "add item" logic? Buried 12 layers deep:
public class AddItemCommandHandler : ICartCommandHandler
{
    private readonly ICartItemFactory _factory;
    private readonly ICartEventMediator _mediator;
    private readonly ICartRepository _repo;
    private readonly ICartUnitOfWork _uow;

    public void Handle(ICartCommand cmd)
    {
        var item = _factory.Create(((AddItemCommand)cmd).Product);
        // ... 6 more lines of delegation
        _mediator.Publish(new ItemAddedEvent(item));
        _uow.Commit();
    }
}
// Total: 14 types to do what ONE method call achieves.

public class ShoppingCart
{
    private List<ICartComponent> _components = new();
    private List<IDiscountStrategy> _discounts = new();

    // No lock — concurrent access will corrupt state
    public void AddItem(IProduct product, int qty)
    {
        _components.Add(new SingleItem(new CartItem(product, qty)));
        // No stock check — what if item is out of stock?
        // No validation — what if qty is negative?
    }

    public void ApplyDiscount(IDiscountStrategy discount)
    {
        _discounts.Add(discount);
        // No expiration check — expired coupons still apply!
    }

    public void AddBundle(ProductBundle bundle)
    {
        _components.Add(bundle);
        // No circular reference check — bundle-in-bundle loops forever
    }

    public decimal CalculateTotal()
    {
        var subtotal = _components.Sum(c => c.GetPrice());
        var discount = _discounts.Sum(d => d.CalculateDiscount(/*...*/));
        return subtotal - discount;
        // Can go negative! No Math.Max(0, ...) guard
    }
}

public class ShoppingCart
{
    private List<CartItem> _items = new(); // Flat list only

    public void AddItem(IProduct product, int qty)
    {
        _items.Add(new CartItem(product, qty));
    }

    // Want to add a "Gaming Pack" bundle?
    // Hack: create a fake product with a manually set price
    public void AddBundle(string bundleName, decimal bundlePrice)
    {
        var fakeProduct = new PhysicalProduct(
            bundleName, bundlePrice, 0, 999);
        _items.Add(new CartItem(fakeProduct));
        // Problem: what's IN the bundle? Nobody knows.
        // Problem: bundle discount applied how? It's just a product.
        // Problem: stock for bundle items? Not tracked individually.
    }

    public decimal Total => _items.Sum(i => i.Subtotal);
    // Can't show "Gaming Pack contains: Keyboard, Mouse, Pad"
    // Can't apply bundle-specific discounts
    // Can't nest bundles inside bundles
}

public class PriceCheckerService
{
    private readonly ShoppingCart _cart;
    private Dictionary<string, decimal> _lastKnownPrices = new();

    // Runs on a background timer every 5 seconds
    public async Task PollForChanges()
    {
        while (true)
        {
            await Task.Delay(5000); // Wait 5 seconds

            foreach (var item in _cart.GetAllItems())
            {
                var currentPrice = GetCurrentPriceFromDb(item.Name);
                if (_lastKnownPrices.TryGetValue(item.Name, out var oldPrice)
                    && currentPrice != oldPrice)
                {
                    Console.WriteLine($"Price changed: {item.Name}!");
                    // 5 seconds late — user might have already checked out
                }
                _lastKnownPrices[item.Name] = currentPrice;
            }
            // This runs 12 times/minute per user.
            // 1000 users = 12,000 DB queries/minute.
            // For something that changes maybe once a day.
        }
    }
}

A candidate submitted this Shopping Cart implementation as a pull request. It compiles. It runs. It handles a basic add-items-and-checkout flow. But there are exactly 5 bugs hiding in it — issues that would cause real problems in production. Can you find them all before scrolling down?

Read the code below carefully. Try to find all 5 issues before revealing the answers.

public class ShoppingCart                                        // Line 1
{
    private List<CartItem> _items = new();                       // Line 3
    private List<IDiscountStrategy> _discounts = new();
    private List<ICartObserver> _observers = new();

    public void AddItem(IProduct product, int quantity)           // Line 7
    {
        var item = new CartItem(product, quantity);
        _items.Add(item);
        foreach (var obs in _observers)                          // Line 11
            obs.OnItemAdded(item);
    }

    public void RemoveItem(string productName)                   // Line 14
    {
        _items.RemoveAll(i => i.Product.Name == productName);
        foreach (var obs in _observers)
            obs.OnItemRemoved(productName);
    }

    public void Subscribe(ICartObserver observer)
    {
        _observers.Add(observer);
    }
    // Note: no Unsubscribe method                               // Line 23

    public void ApplyDiscount(IDiscountStrategy discount)        // Line 25
    {
        _discounts.Add(discount);
    }

    public double GetTotal()                                     // Line 29
    {
        double subtotal = 0;
        foreach (var item in _items)
            subtotal += (double)item.Product.Price * item.Quantity; // Line 32

        foreach (var discount in _discounts)
            subtotal -= (double)discount.CalculateDiscount(_items); // Line 34

        return subtotal;
    }

    public void AddBundle(ProductBundle bundle)                  // Line 38
    {
        foreach (var child in bundle.GetChildren())
        {
            if (child is SingleItem si)                          // Line 41
                _items.Add(GetCartItemFromSingle(si));
            // Ignores nested bundles — flattens only one level
        }
    }
}

Found them? Reveal one at a time:

// Two threads can call AddItem() at the same time
public void AddItem(IProduct product, int quantity)
{
    var item = new CartItem(product, quantity);
    _items.Add(item);  // NOT thread-safe!
    // Thread A adds at index 5
    // Thread B adds at index 5 at the same time
    // Result: one item lost, or internal array corrupted
}

private readonly object _lock = new();

public CartResult<CartItem> AddItem(IProduct product, int quantity)
{
    lock (_lock)  // Only one thread at a time
    {
        var item = new CartItem(product, quantity);
        _items.Add(item);
        NotifyItemAdded(item);
        return CartResult<CartItem>.Ok(item);
    }
}

public double GetTotal()
{
    double subtotal = 0;
    foreach (var item in _items)
        subtotal += (double)item.Product.Price * item.Quantity;
    // $19.99 * 3 = 59.970000000000006 (not 59.97!)
    // Over 10,000 orders: off by $47.32
    return subtotal;
}

public decimal CalculateTotal()
{
    var subtotal = _items.Sum(i => i.Product.Price * i.Quantity);
    // decimal stores values as base-10, not base-2
    // $19.99 * 3 = 59.97 (exactly!)
    var discounts = _discounts.Sum(d => d.CalculateDiscount(_items));
    return Math.Max(0m, Math.Round(subtotal - discounts, 2));
}

var bundle = new ProductBundle("Gaming Pack");
bundle.Add(new SingleItem(keyboard));
bundle.Add(bundle); // Oops! Bundle contains itself!

// Later:
bundle.GetPrice();
// GetPrice() calls children.Sum(c => c.GetPrice())
// One child IS the bundle itself
// So it calls GetPrice() again... and again... and again
// 💥 StackOverflowException

public void Add(ICartComponent component)
{
    // Direct self-reference
    if (component == this)
        throw new InvalidOperationException(
            "A bundle cannot contain itself.");

    // Indirect circular reference (A contains B contains A)
    if (component is ProductBundle pb
        && ContainsRecursive(this, pb))
        throw new InvalidOperationException(
            "Circular bundle reference detected.");

    _children.Add(component);
}

private static bool ContainsRecursive(
    ProductBundle needle, ICartComponent haystack)
{
    foreach (var child in haystack.GetChildren())
    {
        if (child == needle) return true;
        if (child is ProductBundle pb
            && ContainsRecursive(needle, pb))
            return true;
    }
    return false;
}

public void Subscribe(ICartObserver observer)
{
    _observers.Add(observer);
}
// No Unsubscribe method!

// In a web app:
// Request 1: Subscribe(new PriceAlert()) → list has 1 observer
// Request 2: Subscribe(new PriceAlert()) → list has 2 observers
// Request 10000: Subscribe(new PriceAlert()) → list has 10000 observers
// Memory usage: climbing, never drops
// Each AddItem() now fires 10000 notifications
// Performance: degrading, eventually OutOfMemoryException

public void Subscribe(ICartObserver observer) =>
    _observers.Add(observer);

public void Unsubscribe(ICartObserver observer) =>
    _observers.Remove(observer);

// Alternatively, use the IDisposable pattern:
public IDisposable Subscribe(ICartObserver observer)
{
    _observers.Add(observer);
    return new Unsubscriber(_observers, observer);
}

private class Unsubscriber(
    List<ICartObserver> observers,
    ICartObserver observer) : IDisposable
{
    public void Dispose() => observers.Remove(observer);
}

// Usage:
using var subscription = cart.Subscribe(new PriceAlert());
// Automatically unsubscribes when the scope ends

public void ApplyDiscount(IDiscountStrategy discount)
{
    _discounts.Add(discount);
    // No check: is this coupon still valid?
    // "SUMMER20" expired 3 days ago — still applied!
    // "BLACKFRIDAY" was a 24-hour sale — still applied on Saturday!
}

public double GetTotal()
{
    // ...
    foreach (var discount in _discounts)
        subtotal -= (double)discount.CalculateDiscount(_items);
    // No re-check at checkout time either!
    // Coupon could expire BETWEEN adding to cart and checking out
}

public CartResult<bool> ApplyDiscount(IDiscountStrategy discount)
{
    // Check at apply time
    if (discount.IsExpired(_timeProvider.UtcNow))
        return CartResult<bool>.Fail(
            $"Discount '{discount.Name}' has expired.");

    _discounts.Add(discount);
    return CartResult<bool>.Ok(true);
}

public decimal CalculateTotal()
{
    var now = _timeProvider.UtcNow;

    // Re-check at checkout time — might have expired since applying
    _discounts.RemoveAll(d => d.IsExpired(now));

    var subtotal = _components.Sum(c => c.GetPrice());
    var discount = _discounts.Sum(d =>
        d.CalculateDiscount(GetFlatItems()));
    return Math.Max(0m, Math.Round(subtotal - discount, 2));
}

// ITimeProvider is injected (DI) — testable!
// In tests: pass a fake clock that returns any date you want

Shopping Cart is one of the most popular LLD interview questions because it looks deceptively simple. "Add items, calculate total, checkout." But the interviewer is watching for how you discover complexity — bundles, discounts, observers, concurrency. Below are two 30-minute runs: the polished one and the messy-but-honest one. Both get hired.

The CREATES Timeline

Both runs followed the same invisible structure — CREATES. Here's how it maps to the 30-minute interview.

Knowing a great Shopping Cart design and communicating it under interview pressure are two different skills. You can have the perfect Composite + Strategy + Observer architecture in your head and still tank because you can’t narrate it clearly. These 8 cards cover the moments where exact phrasing matters most.

12 questions ranked by difficulty. Each has a "Think" prompt, a solid answer, and the great answer that gets "Strong Hire." These aren't hypothetical — they're the exact questions interviewers ask when they see a Shopping Cart design.

public sealed class ThresholdDiscount(
    decimal threshold, decimal reward) : IDiscountStrategy
{
    public decimal ApplyDiscount(
        IReadOnlyList<ICartComponent> items)
    {
        var subtotal = items.Sum(i => i.GetPrice());
        return subtotal >= threshold
            ? subtotal - reward
            : subtotal;   // below threshold, no discount
    }
}

// Usage — inject at runtime:
var cart = new ShoppingCart(
    new ThresholdDiscount(threshold: 100m, reward: 15m));

// BAD: Polling — UI checks every 100ms
while (true)
{
    var total = cart.GetTotal();  // wasteful if nothing changed
    UpdateDisplay(total);
    Thread.Sleep(100);
}

// GOOD: Observer — cart pushes when it actually changes
public void AddItem(ICartComponent item)
{
    _items.Add(item);
    NotifyObservers();  // only fires when something changed
}

// UI observer — receives push notification
public class PriceDisplayObserver : ICartObserver
{
    public void OnCartChanged(CartSnapshot snapshot)
        => UpdateDisplay(snapshot.Total);
}

public CartResult<bool> AddComponent(ICartComponent child)
{
    if (child == this)
        return CartResult<bool>.Fail("Can't add bundle to itself");

    if (child is ProductBundle bundle && bundle.ContainsAnywhere(this))
        return CartResult<bool>.Fail("Circular bundle detected");

    _children.Add(child);
    return CartResult<bool>.Ok(true);
}

private bool ContainsAnywhere(ICartComponent target)
    => _children.Any(c => c == target
        || (c is ProductBundle b && b.ContainsAnywhere(target)));

public sealed class GiftWrappedItem(
    ICartComponent inner,
    decimal wrappingFee = 4.99m) : ICartComponent
{
    public string Name => $"{inner.Name} (Gift Wrapped)";

    public decimal GetPrice()
        => inner.GetPrice() + wrappingFee;
}

// Usage: wrap any item or bundle
var wrapped = new GiftWrappedItem(gamingBundle);
cart.AddItem(wrapped);  // cart doesn't know it's wrapped

public class ABTestDiscountFactory : IDiscountStrategyFactory
{
    private readonly IDiscountStrategy _groupA = new PercentageDiscount(0.20m);
    private readonly IDiscountStrategy _groupB = new ThresholdDiscount(100m, 15m);

    public IDiscountStrategy GetStrategy(string userId)
    {
        // Deterministic bucket: same user always gets same group
        var bucket = Math.Abs(userId.GetHashCode()) % 2;
        return bucket == 0 ? _groupA : _groupB;
    }
}

// Cart doesn't know it's in an experiment:
var strategy = abFactory.GetStrategy(user.Id);
var cart = new ShoppingCart(strategy);  // just a normal strategy

Every one of these has ended real interviews. Shopping Cart feels like an "easy" problem, so candidates lower their guard and walk straight into traps that interviewers have seen hundreds of times.

● Critical Mistakes — Interview Enders

public class ShoppingCart // does EVERYTHING
{
    public void AddItem(Product p) { ... }
    public decimal CalculateDiscount(string type) { ... }
    public decimal GetShipping() { ... }
    public bool Checkout(string paymentMethod) { ... }
    public void NotifyUI() { ... }
    // 400+ lines of tangled logic
}

ShoppingCart         // owns items, delegates pricing
ICartComponent       // Composite: items + bundles
IDiscountStrategy    // Strategy: discount algorithms
ICartObserver        // Observer: UI, analytics, stock
ICheckoutService     // checkout is its own concern
// Each class: one job. Change discounts without touching cart.

● Serious Mistakes — Red Flags

● Minor Mistakes — Missed Opportunities

You just built a Shopping Cart from scratch and discovered three design patterns along the way. Now let's lock those patterns into long-term memory. The trick isn't repetition — it's anchoring each concept to something vivid. A story, a place, a picture. When you can "see" it, you can recall it under interview pressure.

Memory Palace — Walk Through the Shopping Cart

Imagine walking through a physical store with a shopping cart. Each section of the store maps to a design concept. As you push your cart through, the entire architecture clicks into place.

Smell → Pattern Quick Reference

These are the design instincts you built during this case study. When you notice these smells in ANY system, you already know the fix.

Flashcards — Quiz Yourself

Click each card to reveal the answer. If you can answer without peeking, the pattern is sticking.

5 Things to ALWAYS Mention in a Shopping Cart Interview

You didn't just learn how to build a shopping cart. You learned three structural thinking moves — tree-based composition, swappable algorithms, and push-based notifications. Those ideas appear in virtually every system that manages hierarchies, choices, and real-time updates. Here's the proof: the same techniques applied to four completely different domains.

Six thinking tools you picked up in this case study. Each one is a portable mental move — not a Shopping Cart trick, but something you can use in any LLD interview or real-world design.

Three exercises that test whether you truly learned the thinking, not just memorized the code. Each one adds a new constraint that forces you to extend the design — exactly like a real interview follow-up question.

// Base gift wrapping decorator
public sealed class GiftWrappedItem(ICartComponent inner) : ICartComponent
{
    public string Name => $"{inner.Name} (Gift Wrapped)";
    public decimal GetPrice() => inner.GetPrice() + 4.99m;
}

// Premium wrapping with message
public sealed class PremiumWrappedItem(
    ICartComponent inner, string message) : ICartComponent
{
    public string Name => $"{inner.Name} (Premium Gift: {message})";
    public decimal GetPrice() => inner.GetPrice() + 9.99m;
}

// Usage: wrap a single item
var book = new SingleItem("C# in Depth", 49.99m);
var wrapped = new GiftWrappedItem(book);
// wrapped.GetPrice() == 54.98

// Usage: wrap a BUNDLE
var bundle = new ProductBundle("Starter Pack");
bundle.AddComponent(new SingleItem("Game", 69m));
bundle.AddComponent(new SingleItem("Headset", 39m));
var wrappedBundle = new PremiumWrappedItem(bundle, "Happy Birthday!");
// wrappedBundle.GetPrice() == 69 + 39 + 9.99 = 117.99

// Cart sees ICartComponent — doesn't know about wrapping
cart.AddItem(wrappedBundle);

public record CartEntry(ICartComponent Item, DateTimeOffset AddedAt);

public class ShoppingCart
{
    private readonly List<CartEntry> _entries = new();
    private readonly TimeSpan _expiryWindow = TimeSpan.FromHours(24);

    public void AddItem(ICartComponent item)
    {
        _entries.Add(new CartEntry(item, DateTimeOffset.UtcNow));
        NotifyObservers();
    }

    public int RemoveExpiredItems()
    {
        var cutoff = DateTimeOffset.UtcNow - _expiryWindow;
        var expired = _entries.Where(e => e.AddedAt < cutoff).ToList();

        foreach (var entry in expired)
        {
            _entries.Remove(entry);
            _inventoryService.ReturnStock(entry.Item);
        }

        if (expired.Count > 0)
            NotifyObservers(); // Observer handles user notification

        return expired.Count;
    }
}

// Background service (hosted service in ASP.NET Core)
public class CartExpiryHostedService(
    ICartRepository carts) : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken ct)
    {
        while (!ct.IsCancellationRequested)
        {
            foreach (var cart in await carts.GetActiveCarts())
                cart.RemoveExpiredItems();

            await Task.Delay(TimeSpan.FromMinutes(15), ct);
        }
    }
}

// Each pricing rule adjusts the price independently
public interface IPricingRule
{
    decimal AdjustPrice(decimal basePrice, PricingContext ctx);
}

public sealed class SurgePricingRule(
    IDemandTracker demand) : IPricingRule
{
    public decimal AdjustPrice(decimal price, PricingContext ctx)
    {
        var multiplier = demand.GetMultiplier(ctx.ProductId);
        return price * multiplier; // e.g., 1.2x during high demand
    }
}

public sealed class BulkDiscountRule : IPricingRule
{
    public decimal AdjustPrice(decimal price, PricingContext ctx)
        => ctx.Quantity >= 5 ? price * 0.90m : price;
}

// Engine chains all rules
public class PricingEngine(IReadOnlyList<IPricingRule> rules)
{
    public decimal CalculatePrice(decimal basePrice, PricingContext ctx)
        => rules.Aggregate(basePrice,
            (current, rule) => rule.AdjustPrice(current, ctx));
}

// Decorator that makes any item dynamically priced
public sealed class DynamicallyPricedItem(
    ICartComponent inner,
    PricingEngine engine,
    PricingContext ctx) : ICartComponent
{
    public string Name => inner.Name;
    public decimal GetPrice()
        => engine.CalculatePrice(inner.GetPrice(), ctx);
}

// When surge pricing changes, Observer notifies all carts
// to recalculate their totals

You've discovered patterns, principles, and thinking tools in this case study. Here's where to go next — each page below deepens a specific skill you've already started building.

Patterns Used in This Case Study

Principles Behind the Design

Next Case Studies