Substituir Condicional pelo Polimorfismo de maneira adequada?

Considere duas classes Doge Catambas em conformidade com o Animalprotocolo (em termos da linguagem de programação Swift. Essa seria a interface em Java / C #).

Temos uma tela exibindo uma lista mista de cães e gatos. Há Interactorclasse que lida com a lógica nos bastidores.

Agora, queremos apresentar um alerta de confirmação ao usuário quando ele desejar excluir um gato. No entanto, os cães precisam ser excluídos imediatamente, sem nenhum alerta. O método com condicionais ficaria assim:

func tryToDeleteModel(model: Animal) {
    if let model = model as? Cat {
        tellSceneToShowConfirmationAlert()
    } else if let model = model as? Dog {
        deleteModel(model: model)
    }
}

Como esse código pode ser refatorado? Obviamente cheira

Você está deixando o próprio tipo de protocolo determinar o comportamento. Você deseja tratar todos os protocolos da mesma forma em todo o programa, exceto na própria classe de implementação. Fazer dessa maneira é respeitar o Princípio da Substituição de Liskov, que diz que você deve ser capaz de aprovar um Catou outro Dog(ou qualquer outro protocolo que você possa eventualmente ter sob Animalpotencial) e fazê-lo funcionar de maneira indiferente.

Então, presumivelmente, você adicionaria uma isCriticalfunção Animala ser implementada por ambos Doge Cat. Qualquer coisa implementada Dogretornaria falsa e qualquer coisa implementada Catretornaria verdadeira.

Nesse ponto, você só precisa fazer (minhas desculpas se a sintaxe não estiver correta. Não é usuário do Swift):

func tryToDeleteModel(model: Animal) {
    if model.isCritical() {
        tellSceneToShowConfirmationAlert()
    } else {
        deleteModel(model: model)
    }
}

Existe apenas um pequeno problema com isso, e é isso Doge Catsão protocolos, o que significa que eles mesmos não determinam o que isCriticalretorna, deixando isso para todas as classes de implementação para decidirem por si mesmas. Se você tiver muitas implementações, provavelmente valeria a pena criar uma classe extensível Catou Dogque já implementa corretamente isCriticale efetivamente limpa todas as classes implementadoras da necessidade de substituição isCritical.

Se isso não responder à sua pergunta, escreva nos comentários e expandirei minha resposta de acordo!

Tell vs. Ask

A abordagem condicional que você está mostrando, chamaríamos de " perguntar ". É aqui que o cliente consumidor pergunta "de que tipo você é?" e personaliza seu comportamento e interação com os objetos de acordo.

Isso contrasta com a alternativa que chamamos de " contar ". Usando o tell , você envia mais do trabalho para as implementações polimórficas, para que o código do cliente consumidor seja mais simples, sem condicionais e comum, independentemente das implementações possíveis.

Como você deseja usar um alerta de confirmação, você pode tornar isso um recurso explícito da interface. Portanto, você pode ter um método booleano que, opcionalmente, verifica com o usuário e retorna a confirmação booleana. Nas classes que não desejam confirmar, elas simplesmente substituem return true;. Outras implementações podem determinar dinamicamente se desejam usar a confirmação.

O cliente consumidor sempre usaria o método de confirmação, independentemente da subclasse específica com a qual trabalha, o que torna a interação informada em vez de perguntar .

(Outra abordagem seria empurrar a confirmação para a exclusão, mas isso surpreenderia os clientes consumidores que esperam que uma operação de exclusão seja bem-sucedida.)

Determinar se uma confirmação é necessária é de responsabilidade da Catclasse, portanto, habilite-a para executar essa ação. Eu não conheço Kotlin, então vou expressar as coisas em c #. Espero que as idéias também sejam transferíveis para Kotlin.

interface Animal
{
    bool IsOkToDelete();
}

class Cat : Animal
{
    private readonly Func<bool> _confirmation;

    public Cat (Func<bool> confirmation) => _confirmation = confirmation;

    public bool IsOkToDelete() => _confirmation();
}

class Dog : Animal
{
    public bool IsOkToDelete() => true;
}

Em seguida, ao criar uma Catinstância, você a fornecerá TellSceneToShowConfirmationAlert, que precisará retornar truese OK para excluir:

var model = new Cat(TellSceneToShowConfirmationAlert);

E então sua função se torna:

void TryToDeleteModel(Animal model) 
{
    if (model.IsOKToDelete())
    {
        DeleteModel(model)
    }
}

Eu recomendaria ir para um padrão de visitante. Eu fiz uma pequena implementação em Java. Não conheço o Swift, mas você pode adaptá-lo facilmente.

O visitante

public interface AnimalVisitor<R>{
    R visitCat();
    R visitDog();
}

Seu modelo

abstract class Animal { // can also be an interface like VisitableAnimal
    abstract <R> R accept(AnimalVisitor<R> visitor);
}

class Cat extends Animal {
    public <R> R accept(AnimalVisitor<R> visitor) {
         return visitor.visitCat();
     }
}

class Dog extends Animal {
    public <R> R accept(AnimalVisitor<R> visitor) {
         return visitor.visitDog();
     }
}

Ligar para o visitante

public void tryToDelete(Animal animal) {
    animal.accept( new AnimalVisitor<Void>() {
        public Void visitCat() {
            tellSceneToShowConfirmation();
            return null;
        }

        public Void visitDog() {
            deleteModel(animal);
            return null;
        }
    });
}

Você pode ter quantas implementações do AnimalVisitor quiser.

Exemplo:

public void isColorValid(Color color) {
    animal.accept( new AnimalVisitor<Boolean>() {
        public Boolean visitCat() {
            return Color.BLUE.equals(color);
        }

        public Boolean visitDog() {
            return true;
        }
    });
}