so in my application I've got several different customers being "serviced". Each customer has their own implementations of various classes that are all based on interfaces.

With the latest customer being added, I've noticed there will be a lot of duplication of code from another customer but the other customer is in no other way related to them.

I've already got a default implementation for several other customers and roll new ones as i need them.

My question is how do i refactor this and still keep the code clean? If i were a dev new to this code base i would want each customer to either use the default or their own implementation of these classes... but that's a lot of duplication.

+5  A: 

Consider using an abstract base class with abstract or virtual members. Abstract members are essentially equivalent to interface members (they have no build-in behavior, they only guarantee the method exists) whereas virtual members have a default implementation which can be overridden by derived classes.

Your question is really too vague to answer in full, but here's how you can leverage inheritance.

If you want all classes to use the same implementation of a member then that member can be implemented in the base-class.

If you want each class to have its own implementation of a member then you can either use a base-class with abstract members, or an interface.

If you want some classes to use the same implementations and others to use different implementations then implementing the default behavior in the base-class and override it as needed.

My main point is that OOP there is a spectrum of how much or little functionality is in base/abstract/concrete classes. There's no silver-bullet answer, sometimes your base classes will be skeletons and sometimes they'll be fully fleshed-out; it all depends on the specific problem at hand.

While I agree in principle, this *may* become more difficult than other options (e.g. using strategies) *if* the customers do not form a clear hierarchy. In my experience aggregation tends to work better in that case.
Richard J Foster
I agree, but perhaps you could clarify more on the distinctions between strategies and inheritance--I've always implemented the strategy patten with differing degrees of inheritance (sometimes they just implement an interface, sometimes purely abstract base-classes, sometimes largely virtual base-classes)

You may use either inheritance (put common logic to the base class) or aggregation (spread that logic among other classes and make use them from your customers).

+2  A: 

Is there some way that you could create a base class, then a specific implementation for each customer and then using some type of Dependency Injection have that load classes or functionality as needed. You want to really have a DRY system so as to avoid headaches and typos or other similar human mistakes.

just to make sure I understand you; you're suggesting **one** base class for **all** concrete customer classes, right? Not one base-class per concrete class...
Yeah sorry I worded that incorrectly. Yes I meant one base class, with specific implementations for each customer. Then leave the common functionality to DI or some other pattern. Thanks for catching that. I seemed to have missed a part in between. Sometimes you think something but forget to type it.
+1  A: 

It's a bit difficult to know what to suggest without a better understanding of the code... but some things that have worked for me in similar situations include:

  • Use a Strategy, for the duplicated code. I've had most success where the strategy is encapsulated within a class implementing a known interface (one class per alternate strategy). Often in such cases I use some form of Dependency Injection framework (typically StructureMap) to pass the appropriate strategy/strategies to the class.
  • Use some sort of template class (or template methods) for the common item(s).
  • Use a Decorator to add specific functionality to some basic customer.

STW suggested that I should offer some clarification on what I mean by "Strategy" and how that differs from normal inheritance. I imagine inheritance is something you are very familiar with - something (typically a method - either abstract or virtual) in the base class is replaced by an alternate implementation in the derived class.

A strategy (at least the way I typically use it) is normally implemented by a completely different class. Often all that class will contain is the implementation for a single replaceable operation. For example if the "operation" is to perform some validation, you may have a NullValidationStrategy which does nothing and a ParanoidValidationStrategy which makes sure every McGuffin is the correct height, width and specific shade of blue. The reason I usually implement each strategy in its own class is because I try and follow the Single Responsibility Principle which can make it easier to reuse the code later.

As I mentioned above, I typically use a Dependency Injection (DI) framework to "inject" the appropriate strategy via the class constructor, but a similar results may be obtained via other mechanisms - e.g. having a SetSomeOperationStrategy(ISomeOperation StrategyToUse) method, or a property which holds the strategy reference. If you aren't using DI, and the strategy will always be the same for a given customer type, you could always set the correct choices when the class is constructed. If the strategy won't be the same for each instance of a given customer type, then you probably need some sort of customer factory (often a factory method will be sufficient).

Richard J Foster

I'd go with the answer of spinon (got my vote at least), but it's to short so let me elaborate:

Use your interfaces for the default implementation and then use dependency injection. Most tools allow you to define a scope or some criteria how to resolve something.

I assume that you do know the client at some early point of the program. So for ninject you just might want to define a "Module" for each client and load that into the kernel, depending on the client.

So I'd create a "no customization" Module and create a "ClientX" Module for every special case that uses ´Bind.To()` instead. You end up with

  • a base implementation that is clean/default
  • a single place change for a new client (got a new one? Great. Either it works with the default or just needs a single Module that maps the interfaces to other classes)

The rest of the code shouldn't mind and get the dependencies via injection (constructor, property, whatever is easiest to go for. Constructor would probably be the nicest way) and has no special treatment at all.

You could even use a conditional binding in Ninject link text to solve the binding issue without different modules at all (although, depending on the number of clients, this might get messy and should better be separated).

Benjamin Podszun
+1  A: 

I'd recommend the visitor pattern:

As well as the mediator pattern:

Reason being that it sounds like you may benefit from decoupling, or at least more-loose-coupling, the business logic from your classes, based on what you are saying.


I was going to suggest aggregation, as @the_joric suggests, over inheritance, but your description makes it sound like your application is already reasonably well-factored - that there aren't a lot of small classes waiting to be extracted from your existing classes. Assuming that's the case, for any given interface, if you have a perfect class for the new customer already written and ready to go, I would say go ahead and use it. If you're worried about that, for some reason, then take that perfect class, make it abstract, and create empty subclasses for your existing customer and your new customer - and if it's not quite a perfect fit, then that's the way I would go.

Carl Manaster