Delegate Design Pattern

O Pattern Delegate é utilizado para separar contextos e, literalmente, delegar responsabilidades.

Conceito

No padrão Delegate, um objeto delga a responsabilidade de executar uma determinada tarefa e as especialidades da implementação não importa para essa classe "delegadora".

O objeto principal possui uma referência ao delegate, usando um protocolo. Dessa forma, o delegate implementa os métodos do protocolo para realizar a tarefa.

Objetivos principais

1. Desacoplamento: Permite que diferentes classes ou componentes trabalhem juntos sem que conheçam diretamente suas implementações.
2. Reutilização de código: Componentes podem ser reutilizados com diferentes delegados, fornecendo maior flexibilidade.
3. Especialização: Permite que diferentes objetos especializados realizem diferentes tarefas sem modificar o objeto principal.

Estrutura básica

1. Protocolo (interface): Define os métodos que o delegado deve implementar.
2. Objeto principal: É o objeto que precisava realizar alguma ação, mas delega a tarefa ao delegado.
3. Objeto delegado: É o objeto que realmente executa a ação em nome do principal.

Pseudocódigo

classDiagram
    class DelegateProtocol {
        <<protocol>>
        +doSomething()
    }

    class Main {
        -delegate: DelegateProtocol
        +mainMethod()
    }

    class Delegate {
        +doSomething()
    }

    Main --> DelegateProtocol : delegate
    Delegate ..|> DelegateProtocol : implements

interface DelegateInterface is
    method doSomething()


class Main
    field delegate: DelegateInterface?
    
    method mainMethod() is
        print("Starting task")
        delegate?.doSomething()


class Delegate implements DelegateInterface
    method doSomething() is
        print("Doing somehting as delegate")


main = Main()
delegate = Delegate()

main.delegate = delegate
main.mainMethod()

Vantagens

• Separação de responsabilidades: A delegação permite que a lógica de uma tarefa seja separada em outra classe.
• Modularização: A delegação permite que o código seja quebrado em partes menores e mais gerenciáveis.
• Facilidade de substituição: O comportamento delegado pode ser facilmente substituído sem alterar o objeto principal.
• Facilita testes: Ao usar delegates, é possível simular comportamentos para realizar testes sem ter que alterar o código original.
• Extensibilidade: O delegate permite que uma funcionalidade seja estendida, caso a implementação do protocolo lide de forma diferente com a delegação de responsabilidade.

Referências

Replace Inheritance with Delegation Omar Saibaa, Delegate Design Pattern in iOS