CODEWITHSUNDEEP
ooprefactoring
Dmitriy Polisadov
Dmitriy Polisadov

Reputation: 3

Replace Conditional with Polymorphism — how it works?

Often i heard that "try to avoid if/switch constructions. If you have them then refactor them to subclasses" I don't realize how this thing works. Ok, you have a if/switch in your code. And you create several new classes. But to decide which class you will use you need to implement switch if in fabric class (where you generate these objects). Am i wrong?

P.S. Sorry for my English. I'm reader, not writer.

Upvotes: 0

Views: 690

Answers (1)

Nikhil Vartak
Nikhil Vartak

Reputation: 5117

But to decide which class you will use you need to implement switch if in fabric class (where you generate these objects). Am i wrong?

No, you are not wrong. While the Polymorphism over switches is a good thing, there are exceptions. One such exception is when you have parameterized factory, and that's absolutely acceptable. So instead of your client code creating specialized classes based on conditions, you will ask such factory to create them for you. Advantage is Factory will solely be responsible for creating those class instances, and if new class is introduced only factory will be modified not client code.

So instead of this:

public class Client {
    public string Serialize<T>(string contentType, T instance) where T : class {
        switch(contentType) {
            case "XML":
                return new XMLSerializer().Serialize(instance);
            case "JSON":
                return new JSONSerializer().Serialize(instance);
        }
    }
}

You will have this:

public interface ISerializer {
    string Serialize(object instance);
    object Deserialize(string content);
}

public class XMLSerializer : ISerializer { }
public class JSONSerializer : ISerializer { }

public class SerializerFactory() {
    public static ISerializer CreateSerializer(string type) {
        switch(type) {
            case "XML":
                return new XMLSerializer();
            case "JSON":
                return new JSONSerializer();
        }
    }
}

public class Client {
    public string ParseAPIResponse(string contentType, string responseData) {
        ISerializer serializer = SerializerFactory.CreateSerializer(contentType);
        var responseObj = serializer.Deserialize(responseData);
    }
}

Note there can be only one reason for Factory to change and that is introduction of new Serializer, so we are good on SRP here. Going even further there are ways by which you can avoid modifying factory too, using config files to store identifier-type mappings or simply exposing another method on factory to allow it's users to register new types etc. That's on you.

Upvotes: 2

Related Questions