🎯Desvendando o Princípio da Segregação de Interfaces (ISP)📦

O Princípio da Segregação de Interfaces (Interface Segregation Principle — ISP) estabelece que uma classe não deve ser forçada a depender de interfaces que ela não usa. Em outras palavras, uma interface deve ser segregada em interfaces menores e mais específicas, para que as classes possam implementar apenas as partes da interface que são relevantes para elas.

Suponha que estamos modelando um sistema para um editor de texto, onde diferentes tipos de plugins podem ser adicionados. Vamos aplicar o ISP para criar interfaces segregadas para plugins de formatação de texto e plugins de verificação ortográfica.

using System;

// Interface segregada para plugins de formatação de texto.
interface IPluginFormatacao
{
    void FormatarTexto(string texto);
}

// Interface segregada para plugins de verificação ortográfica.
interface IPluginVerificacaoOrtografica
{
    void VerificarOrtografia(string texto);
}

// Plugin de formatação de texto simples.
class PluginFormatacaoSimples : IPluginFormatacao
{
    public void FormatarTexto(string texto)
    {
        Console.WriteLine("Texto formatado simplesmente: " + texto);
    }
}

// Plugin de verificação ortográfica avançada.
class PluginVerificacaoOrtograficaAvancada : IPluginVerificacaoOrtografica
{
    public void VerificarOrtografia(string texto)
    {
        Console.WriteLine("Verificação ortográfica avançada: " + texto);
    }
}

class EditorDeTexto
{
    public void ExecutarPluginFormatacao(IPluginFormatacao plugin, string texto)
    {
        plugin.FormatarTexto(texto);
    }

    public void ExecutarPluginVerificacaoOrtografica(IPluginVerificacaoOrtografica plugin, string texto)
    {
        plugin.VerificarOrtografia(texto);
    }
}

class Program
{
    static void Main()
    {
        EditorDeTexto editor = new EditorDeTexto();
        string texto = "Este é um texto de exemplo.";

        // Usando interfaces segregadas para plugins de formatação e verificação ortográfica.
        IPluginFormatacao formatacaoSimples = new PluginFormatacaoSimples();
        IPluginVerificacaoOrtografica verificacaoAvancada = new PluginVerificacaoOrtograficaAvancada();

        editor.ExecutarPluginFormatacao(formatacaoSimples, texto);
        editor.ExecutarPluginVerificacaoOrtografica(verificacaoAvancada, texto);
    }
}

Neste exemplo, temos duas interfaces segregadas, IPluginFormatacao e IPluginVerificacaoOrtografica, cada uma representando uma responsabilidade específica para os plugins. As classes que implementam essas interfaces, como PluginFormatacaoSimples e PluginVerificacaoOrtograficaAvançada, implementam apenas os métodos relevantes para suas respectivas funcionalidades.

O EditorDeTexto pode executar plugins de formatação e plugins de verificação ortográfica sem saber os detalhes específicos de cada plugin, seguindo o ISP. Isso permite que novos plugins sejam adicionados facilmente ao sistema sem afetar o código existente e garante que as classes só dependam das interfaces que são relevantes para elas.