SOLID: расшифровка, реальные примеры нарушений на .NET?

public class OrderService
{
    public void PlaceOrder(Order order)
    {
        if (order.Items.Count == 0) throw new Exception("Пустой заказ");        // валидация
        var total = order.Items.Sum(i => i.Price * i.Qty) * (1 - GetDiscount()); // ценообразование
        using var conn = new SqlConnection("...");                             // доступ к данным
        conn.Execute("INSERT INTO orders ...", order);
        var pdf = GenerateInvoicePdf(order, total);                            // генерация документов
        new SmtpClient("smtp.example.uz").Send("shop@x.uz", order.Email, "Счёт", pdf); // рассылка
        File.AppendAllText("log.txt", $"Order {order.Id}");                    // логирование
    }
}

public sealed class PlaceOrderHandler(
    IValidator<PlaceOrder> validator,
    IPricingService pricing,
    IOrderRepository orders,
    IInvoiceGenerator invoices,
    INotificationSender notifications)
{
    public async Task<Guid> Handle(PlaceOrder cmd, CancellationToken ct)
    {
        await validator.ValidateAndThrowAsync(cmd, ct);
        var order = Order.Create(cmd.CustomerId, cmd.Items, pricing.CalculateDiscount(cmd));
        await orders.AddAsync(order, ct);
        var invoice = invoices.Generate(order);
        await notifications.SendInvoiceAsync(order.CustomerEmail, invoice, ct);
        return order.Id;
    }
}

public decimal CalculateFee(Payment p) => p.Method switch
{
    "card"   => p.Amount * 0.02m,
    "wallet" => p.Amount * 0.01m,
    "cash"   => 0,
    // завтра "installments", послезавтра "crypto" — снова открываем этот файл
    _ => throw new NotSupportedException()
};

public interface IPaymentFeePolicy
{
    string Method { get; }
    decimal Calculate(decimal amount);
}

public sealed class CardFeePolicy : IPaymentFeePolicy { public string Method => "card"; public decimal Calculate(decimal a) => a * 0.02m; }
public sealed class WalletFeePolicy : IPaymentFeePolicy { public string Method => "wallet"; public decimal Calculate(decimal a) => a * 0.01m; }

public sealed class FeeCalculator(IEnumerable<IPaymentFeePolicy> policies)
{
    private readonly Dictionary<string, IPaymentFeePolicy> _byMethod = policies.ToDictionary(p => p.Method);
    public decimal Calculate(Payment p) => _byMethod.TryGetValue(p.Method, out var policy)
        ? policy.Calculate(p.Amount)
        : throw new NotSupportedException(p.Method);
}

// Новый способ оплаты = новый класс + регистрация, существующий код не трогаем
builder.Services.AddSingleton<IPaymentFeePolicy, InstallmentsFeePolicy>();

// 1. ReadOnlyCollection<T> реализует ICollection<T>, но Add бросает NotSupportedException.
ICollection<int> items = new ReadOnlyCollection<int>(new List<int>());
items.Add(1);   // NotSupportedException — клиент, получивший ICollection, этого не ожидает

// 2. Массив ковариантен — и может упасть при записи
object[] arr = new string[1];
arr[0] = 42;    // ArrayTypeMismatchException

// 3. Наследник усиливает предусловия
public class FileStorage { public virtual Task SaveAsync(string path, Stream s) => ...; }
public class S3Storage : FileStorage
{
    public override Task SaveAsync(string path, Stream s)
    {
        if (s.Length > 5_000_000) throw new InvalidOperationException("Лимит 5 МБ");   // базовый контракт такого не обещал
        return ...;
    }
}

public interface IRepository<T>
{
    Task<T?> GetAsync(Guid id);
    Task<IReadOnlyList<T>> SearchAsync(string q);
    Task AddAsync(T entity);
    Task UpdateAsync(T entity);
    Task DeleteAsync(Guid id);
    Task BulkImportAsync(Stream csv);
    Task<byte[]> ExportToExcelAsync();
}

// Сервису отчётов нужно только чтение, но он зависит от всего; тестовый фейк реализует 7 методов
public class AuditLogRepository : IRepository<AuditEntry>
{
    public Task DeleteAsync(Guid id) => throw new NotSupportedException();   // журнал аудита нельзя удалять — нарушение LSP как следствие
    // ...
}

public interface IReadRepository<T> { Task<T?> GetAsync(Guid id); Task<IReadOnlyList<T>> SearchAsync(string q); }
public interface IWriteRepository<T> { Task AddAsync(T entity); Task UpdateAsync(T entity); }
public interface IDeletable { Task DeleteAsync(Guid id); }

public class AuditLogRepository : IReadRepository<AuditEntry>, IWriteRepository<AuditEntry> { /* без Delete */ }

// Нарушение
public class ReportService
{
    private readonly SqlConnection _conn = new("Server=prod;...");   // жёсткая зависимость от конкретной БД
    public DateTime Now => DateTime.Now;                              // скрытая зависимость от системных часов
}

// Исправление
public class ReportService(IReportRepository repository, TimeProvider clock)
{
    public async Task<Report> BuildDailyAsync(CancellationToken ct)
    {
        var today = DateOnly.FromDateTime(clock.GetLocalNow().DateTime);
        return new Report(today, await repository.GetSalesAsync(today, ct));
    }
}