// Without Bridge: subclass explosion
// Add one new notification type → need new class for every channel
class EmailOrderNotification { }
class SmsOrderNotification { }
class PushOrderNotification { }
class EmailShipmentNotification { }
class SmsShipmentNotification { }
class PushShipmentNotification { }
// N notification types × M channels = N×M classes

// IMPLEMENTATION side — how to send a message
public interface IMessageChannel
{
    Task SendAsync(string recipient, string subject, string body);
}

public class EmailChannel : IMessageChannel
{
    public async Task SendAsync(string recipient, string subject, string body)
    {
        Console.WriteLine($"[Email → {recipient}] {subject}: {body}");
        // real SMTP logic here
    }
}

public class SmsChannel : IMessageChannel
{
    public async Task SendAsync(string recipient, string subject, string body)
    {
        Console.WriteLine($"[SMS → {recipient}] {body}");   // SMS ignores subject
    }
}

public class PushChannel : IMessageChannel
{
    public async Task SendAsync(string recipient, string subject, string body)
    {
        Console.WriteLine($"[Push → {recipient}] {subject}");   // Push shows title only
    }
}

// ABSTRACTION side — what message to compose
public abstract class Notification(IMessageChannel channel)
{
    protected IMessageChannel Channel { get; } = channel;

    public abstract Task SendAsync(string recipient);
}

public class OrderConfirmationNotification(IMessageChannel channel, int orderId, decimal total)
    : Notification(channel)
{
    public override Task SendAsync(string recipient)
        => Channel.SendAsync(
            recipient,
            subject: "Order Confirmed",
            body:    $"Your order #{orderId} for £{total:F2} has been confirmed."
        );
}

public class ShipmentNotification(IMessageChannel channel, string trackingCode)
    : Notification(channel)
{
    public override Task SendAsync(string recipient)
        => Channel.SendAsync(
            recipient,
            subject: "Your order has shipped",
            body:    $"Track your parcel: {trackingCode}"
        );
}

// Mix and match — N + M classes instead of N × M
var emailOrder = new OrderConfirmationNotification(new EmailChannel(), 42, 99.99m);
var smsShip   = new ShipmentNotification(new SmsChannel(), "TRK-001");

await emailOrder.SendAsync("alice@example.com");
await smsShip.SendAsync("+44 7700 000000");

// Register channels as named services
builder.Services.AddKeyedScoped<IMessageChannel, EmailChannel>("email");
builder.Services.AddKeyedScoped<IMessageChannel, SmsChannel>("sms");
builder.Services.AddKeyedScoped<IMessageChannel, PushChannel>("push");

// Notification factory selects channel at runtime
public class NotificationDispatcher(IServiceProvider sp)
{
    public async Task DispatchAsync(NotificationRequest req)
    {
        var channel = sp.GetRequiredKeyedService<IMessageChannel>(req.Channel);
        Notification notification = req.Type switch
        {
            "order"    => new OrderConfirmationNotification(channel, req.OrderId, req.Total),
            "shipment" => new ShipmentNotification(channel, req.TrackingCode),
            _ => throw new ArgumentException($"Unknown notification type: {req.Type}"),
        };
        await notification.SendAsync(req.Recipient);
    }
}

Adapter:   fixes a design mismatch — incompatible interfaces made compatible post-hoc
Bridge:    designed upfront to separate two dimensions that both need to vary
Strategy:  replaces a single algorithm — one abstraction, many implementations (simpler)

Use Bridge when: you have two orthogonal axes of variation
  (e.g., notification type × delivery channel)
  (e.g., shape type × rendering engine)
  (e.g., query type × database backend)