What does the Single Responsibility Principle really mean, and how do you apply it in a .NET codebase without creating hundreds of tiny classes?

1. Where the definition came from

The "actor" framing is the useful one: it tells you how to find the boundaries (follow the people and forces that drive change).

2. Responsibilities and their natural homes

3. SRP at every level

Violations at higher levels are costlier: a "shared" service owned by nobody that every team changes is the service-level equivalent of OrderManager.

4. Cross-cutting concerns without clutter

// Decorator: auditing wraps the handler without changing it
public sealed class AuditingIssueInvoiceHandler(IIssueInvoiceHandler inner, IAuditLog audit) : IIssueInvoiceHandler
{
    public async Task HandleAsync(Order order, CancellationToken ct)
    {
        await inner.HandleAsync(order, ct);
        await audit.RecordAsync("InvoiceIssued", order.Id, ct);
    }
}

Other .NET homes: ASP.NET Core middleware, endpoint filters, MVC filters, MediatR pipeline behaviours, EF Core interceptors, HttpClient delegating handlers.

5. Measuring (as hints)

Use them to choose where to look, then apply judgement.

6. Try it yourself

1. Pick a large service class and run git log --format="%ad %s" --date=short -- path/to/File.cs.
2. Label each change with the actor who asked for it; count distinct actors.
3. Sketch the split by actor, plus the orchestrator.
4. Identify which methods would move together; check they share fields (cohesion).
5. Move one cross-cutting concern (e.g. logging) into a decorator or pipeline behaviour.
6. Find a place where code is over-split (files that always change together) and consider merging it.

using Microsoft.EntityFrameworkCore;

// Before: one class, three actors (finance, marketing, persistence).
public sealed class InvoiceServiceBefore(AppDb db, IEmailSender email)
{
    public async Task IssueAsync(Order order, CancellationToken ct)
    {
        decimal tax = order.Country == "AU" ? order.Subtotal * 0.10m : 0m;          // finance rule
        string body = $"Thanks {order.CustomerName}. Your total is {order.Subtotal + tax:C}."; // marketing wording
        db.Invoices.Add(new Invoice { OrderId = order.Id, Total = order.Subtotal + tax });     // persistence
        await db.SaveChangesAsync(ct);
        await email.SendAsync(order.Email, "Your invoice", body, ct);
    }
}

// After: each class has one reason to change; the handler only coordinates.
public sealed class TaxCalculator
{
    public decimal TaxFor(Order order) => order.Country == "AU" ? order.Subtotal * 0.10m : 0m;
}

public sealed class InvoiceEmail(IEmailSender email)
{
    public Task SendAsync(Order order, decimal total, CancellationToken ct) =>
        email.SendAsync(order.Email, "Your invoice",
            $"Thanks {order.CustomerName}. Your total is {total:C}.", ct);
}

public sealed class IssueInvoiceHandler(AppDb db, TaxCalculator tax, InvoiceEmail invoiceEmail)
{
    public async Task HandleAsync(Order order, CancellationToken ct)
    {
        decimal total = order.Subtotal + tax.TaxFor(order);
        db.Invoices.Add(new Invoice { OrderId = order.Id, Total = total });
        await db.SaveChangesAsync(ct);
        await invoiceEmail.SendAsync(order, total, ct);
    }
}

public sealed record Order(int Id, string CustomerName, string Email, string Country, decimal Subtotal);

public sealed class Invoice
{
    public int Id { get; set; }
    public int OrderId { get; set; }
    public decimal Total { get; set; }
}

public interface IEmailSender
{
    Task SendAsync(string to, string subject, string body, CancellationToken ct);
}

public sealed class AppDb(DbContextOptions<AppDb> options) : DbContext(options)
{
    public DbSet<Invoice> Invoices => Set<Invoice>();
}