SOLID trong C#

Mỗi class chỉ nên phục vụ một nhóm người / một mối quan tâm. "Một trách nhiệm" không có nghĩa là "một method", mà là chỉ có một lý do khiến class phải sửa.

• Tên class chứa chữ Manager, Helper, Utils, Processor và dài hàng nghìn dòng.
• Một class vừa xử lý nghiệp vụ, vừa truy cập database, vừa gửi email, vừa ghi log.
• Khi mô tả class bạn phải dùng chữ "và" nhiều lần.

public class OrderService
{
    public void PlaceOrder(Order order)
    {
        // 1. Kiểm tra dữ liệu
        if (order.Items.Count == 0)
            throw new InvalidOperationException("Đơn hàng trống");

        // 2. Lưu database
        using var conn = new SqlConnection("Server=...;Database=Shop");
        conn.Open();
        var cmd = new SqlCommand("INSERT INTO Orders ...", conn);
        cmd.ExecuteNonQuery();

        // 3. Gửi email xác nhận
        var smtp = new SmtpClient("smtp.gmail.com");
        smtp.Send("shop@pounitech.com", order.CustomerEmail,
                  "Xác nhận đơn hàng", $"Đơn #{order.Id} đã được tạo");

        // 4. Ghi log
        File.AppendAllText("log.txt", $"{DateTime.Now}: Order {order.Id}\n");
    }
}

OrderService có ít nhất 4 lý do để thay đổi: đổi quy tắc kiểm tra, đổi database, đổi nhà cung cấp email, đổi cách ghi log. Sửa bất kỳ phần nào cũng có nguy cơ làm hỏng phần khác, và gần như không thể viết unit test.

public class OrderValidator
{
    public void Validate(Order order)
    {
        if (order.Items.Count == 0)
            throw new InvalidOperationException("Đơn hàng trống");
    }
}

public class OrderRepository
{
    public void Save(Order order) { /* chỉ lo lưu database */ }
}

public class OrderEmailSender
{
    public void SendConfirmation(Order order) { /* chỉ lo gửi email */ }
}

// OrderService giờ chỉ "điều phối" quy trình đặt hàng
public class OrderService
{
    private readonly OrderValidator _validator;
    private readonly OrderRepository _repository;
    private readonly OrderEmailSender _emailSender;
    private readonly ILogger<OrderService> _logger;

    public OrderService(OrderValidator validator, OrderRepository repository,
                        OrderEmailSender emailSender, ILogger<OrderService> logger)
    {
        _validator = validator;
        _repository = repository;
        _emailSender = emailSender;
        _logger = logger;
    }

    public void PlaceOrder(Order order)
    {
        _validator.Validate(order);
        _repository.Save(order);
        _emailSender.SendConfirmation(order);
        _logger.LogInformation("Order {OrderId} placed", order.Id);
    }
}

Khi có yêu cầu mới, ta thêm code mới (class mới, implementation mới) thay vì sửa code cũ đã chạy ổn định. Công cụ chính trong C#: interface, abstract class, polymorphism.

• Chuỗi if/else hoặc switch dài theo "loại" (type, kind, method…).
• Mỗi lần thêm một loại mới phải mở lại cùng một file để sửa.

public class ShippingCalculator
{
    public decimal Calculate(Order order, string method)
    {
        switch (method)
        {
            case "Standard": return 30_000m;
            case "Express":  return 50_000m + order.Weight * 5_000m;
            case "Free":     return 0m;
            // Thêm "Hỏa tốc"? Lại phải mở file này ra sửa...
            default: throw new ArgumentException("Không hỗ trợ");
        }
    }
}

public interface IShippingMethod
{
    string Name { get; }
    decimal Calculate(Order order);
}

public class StandardShipping : IShippingMethod
{
    public string Name => "Standard";
    public decimal Calculate(Order order) => 30_000m;
}

public class ExpressShipping : IShippingMethod
{
    public string Name => "Express";
    public decimal Calculate(Order order) => 50_000m + order.Weight * 5_000m;
}

// Yêu cầu mới: chỉ cần THÊM class, không đụng vào code cũ
public class SameDayShipping : IShippingMethod
{
    public string Name => "SameDay";
    public decimal Calculate(Order order) => 80_000m;
}

public class ShippingCalculator
{
    private readonly Dictionary<string, IShippingMethod> _methods;

    public ShippingCalculator(IEnumerable<IShippingMethod> methods)
        => _methods = methods.ToDictionary(m => m.Name);

    public decimal Calculate(Order order, string method)
        => _methods.TryGetValue(method, out var m)
            ? m.Calculate(order)
            : throw new ArgumentException($"Không hỗ trợ: {method}");
}

Với ASP.NET Core, chỉ cần đăng ký thêm một dòng services.AddScoped<IShippingMethod, SameDayShipping>() — ShippingCalculator tự nhận phương thức mới mà không phải sửa.

Ở bất kỳ đâu dùng class cha, ta thay bằng class con thì chương trình vẫn phải chạy đúng. Kế thừa phải dựa trên hành vi, không chỉ dựa trên quan hệ "là một" (is-a) ngoài đời thực.

• Class con override method rồi throw NotImplementedException / NotSupportedException.
• Code gọi phải kiểm tra if (x is ClassConCụThể) trước khi dùng.
• Class con làm yếu đi cam kết của cha (nhận ít input hơn, trả kết quả khác ý nghĩa).

public class Rectangle
{
    public virtual int Width { get; set; }
    public virtual int Height { get; set; }
    public int Area => Width * Height;
}

public class Square : Rectangle
{
    // Hình vuông: đổi cạnh này thì cạnh kia đổi theo
    public override int Width  { set { base.Width = base.Height = value; } }
    public override int Height { set { base.Width = base.Height = value; } }
}

void Resize(Rectangle r)
{
    r.Width = 5;
    r.Height = 4;
    Console.WriteLine(r.Area); // Kỳ vọng 20
}

Resize(new Rectangle()); // 20 ✔
Resize(new Square());    // 16 ✘ — hành vi đã bị phá vỡ

Toán học nói "hình vuông là hình chữ nhật", nhưng trong code, Square không giữ được hành vi "đặt chiều rộng và chiều cao độc lập" của Rectangle. Do đó nó không nên kế thừa.

public interface IShape
{
    int Area { get; }
}

public record Rectangle(int Width, int Height) : IShape
{
    public int Area => Width * Height;
}

public record Square(int Side) : IShape
{
    public int Area => Side * Side;
}

// Bất kỳ IShape nào cũng dùng được ở đây mà không bất ngờ
int TotalArea(IEnumerable<IShape> shapes) => shapes.Sum(s => s.Area);

public class FileStorage
{
    public virtual void Write(string path, string content) { /* ... */ }
}

public class ReadOnlyStorage : FileStorage
{
    public override void Write(string path, string content)
        => throw new NotSupportedException(); // ✘ con "từ chối" hành vi của cha
}

Cách sửa: tách thành IReadableStorage và IWritableStorage — điều này dẫn ta tới nguyên tắc tiếp theo.

Đừng ép một class implement những method nó không cần. Hãy chia interface "béo" thành nhiều interface nhỏ theo vai trò; class nào cần vai trò nào thì implement vai trò đó.

• Implementation có nhiều method rỗng hoặc throw NotImplementedException.
• Interface có hàng chục method phục vụ nhiều nhóm client khác nhau.
• Sửa một method trong interface khiến hàng loạt class không liên quan phải build lại.

public interface IMachine
{
    void Print(Document doc);
    void Scan(Document doc);
    void Fax(Document doc);
}

public class BasicPrinter : IMachine
{
    public void Print(Document doc) { /* in */ }
    public void Scan(Document doc) => throw new NotImplementedException();
    public void Fax(Document doc)  => throw new NotImplementedException();
}

public interface IPrinter { void Print(Document doc); }
public interface IScanner { void Scan(Document doc); }
public interface IFax     { void Fax(Document doc); }

public class BasicPrinter : IPrinter
{
    public void Print(Document doc) { /* in */ }
}

public class OfficeMachine : IPrinter, IScanner, IFax
{
    public void Print(Document doc) { /* ... */ }
    public void Scan(Document doc)  { /* ... */ }
    public void Fax(Document doc)   { /* ... */ }
}

// Client chỉ phụ thuộc đúng thứ nó cần
public class ReportService
{
    private readonly IPrinter _printer;
    public ReportService(IPrinter printer) => _printer = printer;
}

Chính .NET cũng áp dụng ISP: IEnumerable<T> (chỉ duyệt), IReadOnlyCollection<T> (thêm Count), ICollection<T> (thêm/xóa), IList<T> (truy cập theo index). Method nào chỉ cần duyệt thì nhận IEnumerable<T> là đủ.

Module cấp cao (nghiệp vụ) không nên biết chi tiết module cấp thấp (SQL Server, SMTP, API bên thứ ba). Cả hai cùng phụ thuộc vào một interface — và interface đó thuộc về phía nghiệp vụ.

• Từ khóa new tạo dependency cụ thể ngay bên trong class nghiệp vụ.
• Không thể unit test vì class luôn gọi database / API thật.
• Đổi từ SQL Server sang PostgreSQL, từ SMTP sang SendGrid… phải sửa code nghiệp vụ.

public class SmtpEmailSender
{
    public void Send(string to, string subject, string body) { /* SMTP */ }
}

public class UserService
{
    // Dính chặt vào SMTP, không thay thế, không mock được
    private readonly SmtpEmailSender _email = new SmtpEmailSender();

    public void Register(string email)
    {
        // ... tạo user
        _email.Send(email, "Chào mừng", "Cảm ơn bạn đã đăng ký Pounitech!");
    }
}

// Abstraction do tầng nghiệp vụ định nghĩa
public interface IEmailSender
{
    Task SendAsync(string to, string subject, string body);
}

// Chi tiết hạ tầng phụ thuộc NGƯỢC LÊN abstraction
public class SmtpEmailSender : IEmailSender
{
    public Task SendAsync(string to, string subject, string body) { /* SMTP */ return Task.CompletedTask; }
}

public class SendGridEmailSender : IEmailSender
{
    public Task SendAsync(string to, string subject, string body) { /* API */ return Task.CompletedTask; }
}

public class UserService
{
    private readonly IEmailSender _email;

    public UserService(IEmailSender email) => _email = email; // nhận qua constructor

    public async Task RegisterAsync(string email)
    {
        // ... tạo user
        await _email.SendAsync(email, "Chào mừng", "Cảm ơn bạn đã đăng ký Pounitech!");
    }
}

// Program.cs
var builder = WebApplication.CreateBuilder(args);

// Đổi nhà cung cấp email chỉ bằng MỘT dòng, không đụng UserService
builder.Services.AddScoped<IEmailSender, SendGridEmailSender>();
builder.Services.AddScoped<UserService>();

var app = builder.Build();

public class FakeEmailSender : IEmailSender
{
    public List<string> SentTo { get; } = new();
    public Task SendAsync(string to, string subject, string body)
    {
        SentTo.Add(to);
        return Task.CompletedTask;
    }
}

[Fact]
public async Task Register_SendsWelcomeEmail()
{
    var fake = new FakeEmailSender();
    var service = new UserService(fake);

    await service.RegisterAsync("an@example.com");

    Assert.Contains("an@example.com", fake.SentTo);
}