What is composition in object-oriented design? Show how a C# class can be built from smaller objects that it owns and delegates to, and explain the benefits for change, testing and reuse.

1. Composition in UML terms

In UML, composition (filled diamond) is the strongest form of association: the whole owns the part, and the part's lifetime depends on the whole (an order line can't exist without its order). Aggregation (hollow diamond) is a weaker "has-a" where parts can be shared or outlive the whole. In everyday design discussions, "composition over inheritance" uses composition more loosely to mean "assemble behaviour from collaborating objects" — including services injected by DI, which the composite doesn't own exclusively.

2. Patterns built on composition

3. Decorators with DI

The built-in container doesn't support decoration directly; options:

• Register manually: services.AddScoped<IProductCatalog>(sp => new CachingProductCatalog(sp.GetRequiredService<SqlProductCatalog>(), sp.GetRequiredService<IMemoryCache>()));
• Use Scrutor's services.Decorate<IProductCatalog, CachingProductCatalog>().
• Use keyed services (.NET 8) to distinguish inner and outer registrations.

4. Ownership and lifetimes

When composing, decide who owns each part:

• Parts created by the composite (new OrderLine(...)) are owned — dispose them if disposable.
• Parts injected by DI are owned by the container — don't dispose them, and respect lifetimes: a singleton composing a scoped service causes a captive dependency (the scoped service lives forever, e.g. a DbContext shared across requests). ValidateScopes in Development catches this.

5. Composition in the domain model

public sealed class Order
{
    private readonly List<OrderLine> _lines = [];        // owned parts
    public ShippingAddress Address { get; private set; } // value object, owned
    public CustomerId CustomerId { get; }                // reference by ID to another aggregate (not owned)
}

In DDD terms, an aggregate is a composition boundary: the root owns its parts, enforces invariants across them, and is persisted as a unit. Other aggregates are referenced by ID, not composed. EF Core models owned parts with owned types or ComplexProperty (EF Core 8) for value objects, and cascade deletes for owned children.

6. Delegation boilerplate

When wrapping a large interface (e.g. Stream), you must forward many members. Options: inherit from a base that forwards (Stream wrappers often derive from Stream and forward), source generators that implement forwarding, or design smaller interfaces so wrappers stay small (Interface Segregation helps composition).

Try it yourself

1. Write a decorator that adds logging and timing to an interface, and register it with Scrutor or manually.
2. Refactor an inheritance-based variation in your code into a strategy injected via DI.
3. Turn on ValidateScopes/ValidateOnBuild and look for captive dependencies.
4. Map an owned value object with EF Core's ComplexProperty and observe the table columns.

public interface INotifier
{
    Task SendAsync(string to, string message, CancellationToken ct);
}

public sealed class EmailNotifier(IEmailClient client) : INotifier
{
    public Task SendAsync(string to, string message, CancellationToken ct) =>
        client.SendAsync(to, "Notification", message, ct);
}

// Decorators: same interface, wrap another INotifier
public sealed class RetryingNotifier(INotifier inner, int attempts = 3) : INotifier
{
    public async Task SendAsync(string to, string message, CancellationToken ct)
    {
        for (int i = 1; ; i++)
        {
            try { await inner.SendAsync(to, message, ct); return; }
            catch (HttpRequestException) when (i < attempts)
            {
                await Task.Delay(TimeSpan.FromMilliseconds(200 * i), ct);
            }
        }
    }
}

public sealed class LoggingNotifier(INotifier inner, ILogger<LoggingNotifier> log) : INotifier
{
    public async Task SendAsync(string to, string message, CancellationToken ct)
    {
        log.LogInformation("Sending notification to {To}", to);
        await inner.SendAsync(to, message, ct);
    }
}

// Composition with owned parts (strict UML composition): lines live and die with the order
public sealed class Order
{
    private readonly List<OrderLine> _lines = [];        // owned, not shared
    public IReadOnlyList<OrderLine> Lines => _lines;
    public void AddLine(string sku, int qty) => _lines.Add(new OrderLine(sku, qty));
}

public sealed record OrderLine(string Sku, int Quantity);

// Wiring the chain
INotifier notifier = new LoggingNotifier(
    new RetryingNotifier(new EmailNotifier(emailClient)), logger);