What is the Interface Segregation Principle, and how do you apply it to repositories, services and libraries in .NET?

1. Origin

Robert C. Martin formulated ISP while consulting for Xerox: a single Job class used by printing, stapling and faxing meant every change to any job type forced recompilation of all clients. Splitting into client-specific interfaces fixed the rebuild cascade. The modern lesson is the same: narrow dependencies limit the blast radius of change.

2. Designing from the consumer

Consumer                   Calls                                 Interface
LoyaltyReport              Search, Get                           ICustomerQueries
ProfileEndpoint            Get, UpdateEmail                      ICustomerQueries + ICustomerCommands
NightlyExportJob           ExportCsv                             ICustomerExport
AdminTool                  Delete, Merge                         ICustomerAdmin

This also documents intent: a constructor taking ICustomerQueries tells reviewers "this class only reads".

3. One implementation, several interfaces in DI

services.AddScoped<CustomerStore>();
services.AddScoped<ICustomerQueries>(sp => sp.GetRequiredService<CustomerStore>());
services.AddScoped<ICustomerCommands>(sp => sp.GetRequiredService<CustomerStore>());
services.AddScoped<ICustomerExport>(sp => sp.GetRequiredService<CustomerStore>());

Forwarding registrations share one scoped instance, so a request that uses queries and commands sees consistent state (e.g. the same DbContext). Registering AddScoped<ICustomerQueries, CustomerStore>() separately would create separate instances.

4. BCL examples

5. ISP in distributed systems

• API contracts: a "god endpoint" or a giant shared DTO couples every client to every field; clients break on unrelated changes. Prefer purpose-specific endpoints and DTOs (or BFFs per client type).
• gRPC/HTTP services: fat service contracts make independent deployment harder; split by consumer/use case.
• Messages/events: small, specific events beat one huge "EntityChanged" payload everyone must parse.

6. Incremental refactoring of a fat interface

1. Introduce the role interfaces; make the existing class implement them in addition to the fat interface.
2. Change consumers one by one to depend on role interfaces.
3. When no consumer uses the fat interface, delete it.
4. Update fakes as you go; they shrink naturally.

No big-bang change needed.

7. Try it yourself

1. Pick your widest interface; list consumers and the members each calls.
2. Cluster the lists; propose role interfaces.
3. Count fake members in tests before and after.
4. Add forwarding DI registrations and verify one instance per scope.
5. Review a public API DTO used by several clients and see which fields each client actually reads.

// Before: every consumer depends on everything.
public interface ICustomerServiceFat
{
    Task<Customer?> GetAsync(int id, CancellationToken ct);
    Task<IReadOnlyList<Customer>> SearchAsync(string text, CancellationToken ct);
    Task CreateAsync(Customer c, CancellationToken ct);
    Task UpdateEmailAsync(int id, string email, CancellationToken ct);
    Task DeleteAsync(int id, CancellationToken ct);
    Task<byte[]> ExportCsvAsync(CancellationToken ct);
    Task RecalculateLoyaltyAsync(CancellationToken ct);
}

// After: role interfaces shaped by their consumers.
public interface ICustomerQueries
{
    Task<Customer?> GetAsync(int id, CancellationToken ct);
    Task<IReadOnlyList<Customer>> SearchAsync(string text, CancellationToken ct);
}

public interface ICustomerCommands
{
    Task CreateAsync(Customer c, CancellationToken ct);
    Task UpdateEmailAsync(int id, string email, CancellationToken ct);
}

public interface ICustomerExport
{
    Task<byte[]> ExportCsvAsync(CancellationToken ct);
}

// One implementation can serve several roles.
public sealed class CustomerStore : ICustomerQueries, ICustomerCommands
{
    private readonly Dictionary<int, Customer> _data = new();
    public Task<Customer?> GetAsync(int id, CancellationToken ct) => Task.FromResult(_data.GetValueOrDefault(id));
    public Task<IReadOnlyList<Customer>> SearchAsync(string text, CancellationToken ct) =>
        Task.FromResult<IReadOnlyList<Customer>>(_data.Values.Where(c => c.Name.Contains(text)).ToList());
    public Task CreateAsync(Customer c, CancellationToken ct) { _data[c.Id] = c; return Task.CompletedTask; }
    public Task UpdateEmailAsync(int id, string email, CancellationToken ct)
    {
        _data[id] = _data[id] with { Email = email };
        return Task.CompletedTask;
    }
}

// A reporting consumer needs only queries, and its test fake has two members.
public sealed class LoyaltyReport(ICustomerQueries customers)
{
    public async Task<int> CountGoldAsync(CancellationToken ct) =>
        (await customers.SearchAsync("", ct)).Count(c => c.Tier == "Gold");
}

public sealed record Customer(int Id, string Name, string Email, string Tier);