All 17 Interfaces & Abstract Classes questions
More in Interfaces & Abstract Classes
How does explicit interface implementation work, and when would you use it instead of a normal (implicit) implementation? When would you choose an abstract class over an interface for extensibility? What is the Interface Segregation Principle and how does it apply in C#? How do static abstract interface members (C# 11+) enable generic math and other 'static polymorphism' patterns? How would you design a class hierarchy combining an abstract base class WITH multiple interfaces to model both shared implementation AND multiple independent capabilities? How does the 'sealed' modifier interact with abstract classes and interface method overrides to control further extensibility? How would you implement the 'Liskov Substitution Principle' correctly when designing an abstract class hierarchy, and what's a classic violation example?
Advertisement
Back to results for “Interfaces & Abstract Classes”
C# › Interfaces & Abstract Classes

How does interface segregation (the 'I' in SOLID) guide splitting a large, monolithic interface into several smaller, more focused ones?

Advanced

Answer

The Interface Segregation Principle states that clients shouldn't be forced to depend on methods they don't actually use — a large interface with many unrelated members should be SPLIT into several smaller, cohesive interfaces, letting each implementing class (and each consumer) depend only on the specific capabilities it genuinely needs.
// Before: monolithic, forces unrelated dependencies
public interface IWorker { void Work(); void Eat(); void Sleep(); }

// After: segregated into focused interfaces
public interface IWorkable { void Work(); }
public interface IFeedable { void Eat(); }
public class Robot : IWorkable { public void Work() { } } // doesn't need Eat/Sleep at all
Real-world example Refactoring a bloated 'god interface' that forces every implementer to stub out methods they don't actually need.

Common follow-ups: How does a segregated interface design specifically improve testability compared to one large interface?

Design Patterns in C#
All 17 Interfaces & Abstract Classes questions