Understanding the C# Interface Segregation Principle (ISP) with Examples

Last updated on September 1st, 2023 at 07:53 pm

In this article, we will learn about the C# Interface Segregation Principle (ISP), which states that a class should not forced to implement Interface methods they don’t use.

It promotes the creation of focused, smaller, and modular interfaces to prevent clients from implementing methods they don’t need. 

We will learn its significance and how it can be applied using C# code examples.

What is the C# Interface Segregation Principle?

The Interface Segregation Principle is one of the five SOLID principles of object-oriented design introduced by Robert C. Martin. 

1. Single Responsibility Principle (SRP)
2. Open-closed Principle (OCP)
3. Liskov substitution Principle (LSP)
4. Interface Segregation Principle (ISP)
5. Dependency Inversion Principle (DIP)

The Interface Segregation Principle states that a class should not be forced to implement an interface that contains methods it doesn’t use.

In simpler terms, it suggests that an interface should have only those methods that are relevant to the implementing class. 

This principle prevents the creation of ‘fat’ interfaces that contain methods unnecessary for certain classes, which can lead to code complexity and tight coupling.

Interface Segregation Principle (ISP) with C# Examples

Let’s dive into practical examples to learn the concept of the Interface Segregation Principle more effectively. We’ll start with a simple scenario and then progress to a more complex one.

Scenario 1: Document Processing System

Suppose we’re building a document processing system that deals with various types of documents, such as PDFs and Word documents. We have an IDocument interface as follows:

public interface IDocument
{
    void Open();
    void Edit();
    void Save();
    void Print();
}

Here, the IDocument interface includes methods for opening, editing, saving, and printing documents. Now, let’s implement this interface in classes for different document types:

public class PDFDocument : IDocument
{
    public void Open() { /* PDF open logic */ }
    public void Edit()
    {    
        throw new NotImplementedException("Editing is not applicable for PDF");
    }
    public void Save() { /* PDF save logic */ }
    public void Print() { /* PDF print logic */ }
}

public class WordDocument : IDocument
{
    public void Open() { /* Word open logic */ }
    public void Edit() { /* Word edit logic */ }
    public void Save() { /* Word save logic */ }
    public void Print() { /* Word print logic */ }
}

In this scenario, the WordDocument class adheres to all the methods defined in the IDocument interface. However, the PDFDocument class doesn’t need the Edit method, making it a victim of the Interface Segregation Principle violation.

Code After Applying the Interface Segregation Principle (ISP)

To resolve the Interface Segregation Principle (ISP) violation, we can refactor the interface into smaller, more focused interfaces. Let’s create separate interfaces such as IEditableDocument for editing and IPrintableDocument for printing:

public interface IDocument
{
    void Open();
    void Save();
}
public interface IEditableDocument
{
    void Edit();
}

public interface IPrintableDocument
{
    void Print();
}


public class PDFDocument : IDocument, IPrintableDocument
{
   public void Open()
    {
        Console.WriteLine("Opening PDF document"); /* PDF open logic */
    }


    public void Save()
    {
        Console.WriteLine("Saving PDF document"); /* PDF save logic */ 
    }

    public void Print()
    {
        Console.WriteLine("Printing PDF document"); /* PDF print logic */
    }
}

public class WordDocument : IDocument, IEditableDocument, IPrintableDocument
{
    
   public void Open()
    {
        Console.WriteLine("Opening Word document");  /* Word open logic */ 
    }

    public void Edit()
    {
        Console.WriteLine("Editing Word document"); /* Word edit logic */
    }

    public void Save()
    {
        Console.WriteLine("Saving Word document"); /* Word save logic */
    }

    public void Print()
    {
        Console.WriteLine("Printing Word document"); /* Word print logic */ 
    }
}

Applying the Interface Segregation Principle (ISP) has helped us design interfaces that suit each class’s exact requirements. This makes our code cleaner and easier to manage. Unnecessary methods that could confuse things are now avoided.

As a result, our document system becomes more flexible and simpler to understand and can be enhanced without adding extra complications.

Benefits of using the Segregation Principle (ISP)

The Interface Segregation Principle (ISP) is a software design principle that states that no client or class should be forced to depend on methods it does not use. 

When we declare methods in an interface that the client doesn’t need, it pollutes the interface and leads to a bulky or fat interface. 

By following this principle, we can create interfaces that are more focused and easier to understand, resulting in a codebase that is more resilient to changes and easier to maintain.

Some of the benefits of using ISP are: – 

• Focused Responsibilities: Each interface has a single responsibility, leading to cleaner and more cohesive code.
• Clearer Code: Clients (Classes) are not forced to depend on methods they do not use. For example, Each type of document (like PDFs and Word documents) only deals with the methods it actually needs. This keeps things simple and avoids unnecessary confusion.
• Easy to Understand: Interfaces are more focused and easier to understand. When you look at a document class(like PDFs and Word), you instantly see which actions it can perform. This clarity helps both new programmers and your future self understand and work with the code.
• Smooth Expansion: Adding a new type of document is easy. You just implement the needed methods. You don’t have to worry about irrelevant methods causing trouble.
• Flexibility: By following ISP, the new classes can be easily added without being forced to implement methods they have no use for. It promotes code extensibility and scalability.
• Elimination of Unnecessary Exceptions: The NotImplementedException issue is eliminated, and our code is free from misleading and unnecessary exceptions.

FAQs: C# Interface Segregation Principle (ISP)

References: MSDN-SOLID Principles in C#

Articles you might also like:

• C# Tutorial
• SOLID Design Principles in C#
•  C# Liskov Substitution Principle
• Design Patterns
• Singleton Design Pattern in C#: A Beginner’s Guide with Examples
• Abstract Factory Design Pattern in C#: Real-World Example and Code Explanations
• Prototype Design Pattern: Everything You Need to Know

• Author
• Recent Posts

Shekh Ali

Meet Sheikh Ali, a skilled Software engineer and passionate a blogger. He enjoys sharing his expertise in C#, Java, SQL, Design Patterns, and other related topics through his writing. When he's not coding, Sheikh Ali can often indulge in his passions for reading books and fitness training.

Latest posts by Shekh Ali (see all)

• C# Program to Capitalize the First Character of Each Word in a String - February 21, 2024
• C# Program to Find the Longest Word in a String - February 19, 2024
• How to Reverse an Array in C# with Examples - February 12, 2024