Princípio de segregação de interface C#

Resumo : neste tutorial, você aprenderá sobre o Princípio de Segregação de Interface (ISP) C# que promove a ideia de criação de interfaces pequenas e focadas que são específicas para as necessidades dos clientes.

Introdução ao princípio de segregação de interface C#

O princípio de segregação de interface é o quarto princípio dos cinco princípios SOLID de design orientado a objetos:

Princípio de Responsabilidade Única (SRP)
Princípio Aberto-Fechado (OCP)
Princípio de Substituição de Liskov (LSP)
Princípio de segregação de interface (ISP)
Princípio de Inversão de Dependência (DIP)

O princípio de segregação de interface sugere que você não deve forçar um cliente a implementar uma interface que contenha métodos desnecessários.

Em vez disso, você deve dividir interfaces maiores em interfaces menores, mais focadas e direcionadas a casos de uso específicos.

O princípio de segregação de interfaces promove a ideia de criar interfaces pequenas e coesas , específicas às necessidades do cliente.

Vejamos um exemplo de violação do princípio de segregação de interface:

namespace ISP;

public interface IVehicle
{
    void Run();
    void Fly();
    
}

public class Aircraft : IVehicle
{
    public void Run() => Console.Write("Running");
    public void Fly() => Console.Write("Flying");
}

public class Car: IVehicle
{
    public void Run() => Console.Write("Running");
    public void Fly() => throw new NotImplementedException();
}

public class Program
{
    public static void Main(string[] args)
    {
        // aircraft 
        var aircraft = new Aircraft();
        aircraft.Run();
        aircraft.Fly();

        // car
        var car = new Car();    
        car.Run();
        
        // cannot fly, exception
        car.Fly(); 
    }
}Linguagem de código:  C#  ( cs )

Como funciona.

Primeiro, defina uma IVehicleinterface interface que tenha dois métodos Run()e Fly():

public interface IVehicle
{
    void Run();
    void Fly();
}Linguagem de código:  C#  ( cs )

Segundo, defina uma Aircraftclasse que implemente a IVehicleinterface:

public class Aircraft : IVehicle
{
    public void Run() => Console.Write("Running");
    public void Fly() => Console.Write("Flying");
}Linguagem de código:  C#  ( cs )

Terceiro, defina uma Carclasse que também implemente a IVehicleinterface. Como um carro normal não pode voar, surge uma exceção no Fly()método:

public class Car: IVehicle
{
    public void Run() => Console.Write("Running");
    public void Fly() => throw new NotImplementedException();
}Linguagem de código:  C#  ( cs )

Finalmente, crie um Aircraftobjeto e chame os métodos Run()e Fly(). Mas quando criamos um Carobjeto e chamamos o Fly()método, surge uma exceção:

public class Program
{
    public static void Main(string[] args)
    {
        // aircraft 
        var aircraft = new Aircraft();
        aircraft.Run();
        aircraft.Fly();

        // car
        var car = new Car();    
        car.Run();
        
        // cannot fly, exception
        car.Fly(); 
    }
}Linguagem de código:  C#  ( cs )

Este é um exemplo de violação do Princípio de Segregação de Interface porque IVehicleforça a Carclasse a usar o Fly()método que não precisa.

Refatorando o programa para estar em conformidade com o Princípio de Segregação de Interface

Para corrigir o problema de violação do princípio de segregação de interface, é necessário dividir a interface grande em interfaces menores.

Primeiro, separe a IVehicleinterface em duas interfaces menores IFlyablee IRunnable:

public interface IFlyable
{
    void Fly();
}
public interface IRunnable
{
    void Run();
}Linguagem de código:  C#  ( cs )

Segundo, defina a Aircraftclasse que implementa ambas as interfaces, já que a Aircraftclasse precisa dos métodos Run()e :Fly()

public class Aircraft : IRunnable, IFlyable
{
    public void Run() => Console.Write("Running");
    public void Fly() => Console.Write("Flying");
}Linguagem de código:  C#  ( cs )

Terceiro, defina a Carclasse que implementa apenas a IRunnableinterface porque ela só precisa do Run()método:

public class Car: IRunnable
{
    public void Run() => Console.Write("Running");
}Linguagem de código:  C#  ( cs )

Por fim, crie objetos Aircrafte Care chame seus métodos respectivamente no Main()método da Programclasse:

public class Program
{
    public static void Main(string[] args)
    {
        // aircraft 
        var aircraft = new Aircraft();
        aircraft.Run();
        aircraft.Fly();

        // car
        var car = new Car();    
        car.Run();        
  
    }
}Linguagem de código:  C#  ( cs )

Junte tudo.

namespace ISP;

public interface IFlyable
{
    void Fly();
}
public interface IRunnable
{
    void Run();
}

public class Aircraft : IRunnable, IFlyable
{
    public void Run() => Console.Write("Running");
    public void Fly() => Console.Write("Flying");
}

public class Car: IRunnable
{
    public void Run() => Console.Write("Running");
}

public class Program
{
    public static void Main(string[] args)
    {
        // aircraft 
        var aircraft = new Aircraft();
        aircraft.Run();
        aircraft.Fly();

        // car
        var car = new Car();    
        car.Run();        
    }
}Linguagem de código:  C#  ( cs )