Ehsan Ghanbari

Experience, DotNet, Solutions

Interface Segregation principle (ISP)

"no client should be forced to depend on methods it does not use." Interface segregation is a Simple but useful pattern of SOLID principle, in other words, interface segregation is just about splitting an interface to several interfaces to make it simple working with classes those are going to implement the members.

Example

Suppose this interface :

 

    public interface IAccountService
    {
        void CreateBankAccount();
        void DeleteBankAccount(Guid accountId);
        void GetAllBankAccounts();
        void GetAccountInfo(Guid accountId);
     } 

 

and AccountService class

 

    public class AccountService  :IAccountService
    {
        public void CreateBankAccount()
        {
            throw new NotImplementedException();
        }
        public void DeleteBankAccount(Guid accountId)
        {
            throw new NotImplementedException();
        }
        public void GetAllBankAccounts()
        {
            throw new NotImplementedException();
        }
        public void GetAccountInfo(Guid accountId)
        {
            throw new NotImplementedException();
        }
    }

 

Account service class is one that admin uses it to access all the implemented method, now we need a UserService for users of the banking system to able to create the account, delete the account, get account information, to do this we implement the IAccountService to this service too, like this :

 

    public class UserService : IAccountService
    {
        public void CreateBankAccount()
        {
            throw new NotImplementedException();
        }
        public void DeleteBankAccount(Guid accountId)
        {
            throw new NotImplementedException();
        }
        public Ilist<Account> GetAllBankAccounts()
        {
            throw new NotImplementedException();
        }
        public Account GetAccountInfo(Guid accountId)
        {
            throw new NotImplementedException();
        }
    }

 

All of the IAccountService members are necessary for UserService but  GetAllBankAccounts(), because users of a bank couldn’t access to all account of the system! We can let the unnecessary members Not Implemented but It's so hideous, isn't it !? To solve this it's better to use Interface segregation pattern, simply add a new interface and change the IAccountService like this :

 

   public interface IAccountService
    {
         IList<Account> GetAllBankAccounts();
    }
    public interface IUserService
    {
        void CreateBankAccount();
        void DeleteBankAccount(Guid accountId);
        Account GetAccountInfo(Guid accountId);
    }

 

And now implement both IAccountService and IUserService for AccountService

 

    public class AccountService  :IAccountService , IUserService
    {
        public IList<Account> GetAllBankAccounts()
        {
            throw new NotImplementedException();
        }
        public void CreateBankAccount()
        {
            throw new NotImplementedException();
        }
        public void DeleteBankAccount(Guid accountId)
        {
            throw new NotImplementedException();
        }
        public Account GetAccountInfo(Guid accountId)
        {
            throw new NotImplementedException();
        }
    }

 

And implement the IUserService members for UserService :

 

    public class UserService : IUserService
    {
        public void CreateBankAccount()
        {
            throw new NotImplementedException();
        }
        public void DeleteBankAccount(Guid accountId)
        {
            throw new NotImplementedException();
        }
        public Account GetAccountInfo(Guid accountId)
        {
            throw new NotImplementedException();
        }
    }

 

Now Every service class implements the needed members, right? If you take a closer look at this simple example rather than making the code more readable by using ISP, it is like the real world or business functionality, my mean every user is able to create, delete and get the account information and admin could see the list of all accounts rather than what Users could do .

About Me

Ehsan Ghanbari

Hi! my name is Ehsan. I'm a developer, passionate technologist, and fan of clean code. I'm interested in enterprise and large-scale applications architecture and design patterns and I'm spending a lot of my time on architecture subject. Since 2008, I've been as a developer for companies and organizations and I've been focusing on Microsoft ecosystem all the time. During the&nb Read More

Post Tags
Pending Blog Posts
Strategic design
Factory Pattern
time out pattern in ajax
Selectors in Jquery
Peridic pattern
How to query over Icollection<> of a type with linq
How to use PagedList In asp.net MVC
Domain driven design VS model driven architecture
Using Generic type for type casting in F#
What's the DDD-lite?
comments powered by Disqus