Recently I received a question from Kelly Sommers about good ways to refactor away from Factory Overload. Basically, she’s working in a code base where there’s an explosion of Abstract Factories which seems to be counter-productive. In this post I’ll take a look at the example problem and propose a set of alternatives.
An Abstract Factory (and its close relative Product Trader) can serve as a solution to various challenges that come up when writing loosely coupled code (chapter 6 of my book describes the most common scenarios). However, introducing an Abstract Factory may be a leaky abstraction, so don’t do it blindly. For example, an Abstract Factory is rarely the best approach to address lifetime management concerns. In other words, the Abstract Factory has to make sense as a pure model element.
That’s not the case in the following example.
Problem Statement
The question centers around a code base that integrates with a database closely guarded by DBA police. Apparently, every single database access must happen through a set of very fine-grained stored procedures.
For example, to update the first name of a user, a set of stored procedures exist to support this scenario, depending on the context of the current application user:
| User type | Stored procedure | Parameter name |
| Admin | update_admin_firstname | adminFirstName |
| Guest | update_guest_firstname | guestFirstName |
| Regular | update_regular_firstname | regularFirstName |
| Restricted | update_restricted_firstname | restrictedFirstName |
As this table demonstrates, not only is there a stored procedure for each user context, but the parameter name differs as well. However, in this particular case it seems as though there’s a pattern to the names.
If this pattern is consistent, I think the easiest way to address these variations would be to algorithmically build the strings from a couple of templates.
However, this is not the route taken by Kelly’s team, so I assume that things are more complicated than that; apparently, a templated approach is not viable, so for the rest of this article I’m going to assume that it’s necessary to write at least some code to address each case individually.
The current solution that Kelly’s team has implemented is to use an Abstract Factory (Product Trader) to translate the user type into an appropriate IUserFirstNameModifier instance. From the consuming code, it looks like this:
var modifier = factory.Create(UserTypes.Admin);
modifier.Commit("first");where the factory variable is an instance of the IUserFirstNameModifierFactory interface. This is certainly loosely coupled, but looks like a leaky abstraction. Why is a factory needed? It seems that its single responsibility is to translate a UserTypes instance (an enum) into an IUserFirstNameModifier. There’s a code smell buried here – try to spot it before you read on :)
Proposed Solution
Kelly herself suggests an alternative involving a concrete Builder which can create instances of a single concrete UserFirstNameModifier with or without an implicit conversion:
// Implicit conversion.
UserFirstNameModifier modifier1 =
builder.WithUserType(UserTypes.Guest);
// Without implicit conversion.
var modifier2 = builder
.WithUserType(UserTypes.Restricted)
.Create();
While this may seem to reduce the number of classes involved, it has several drawbacks:
- First of all, the Fluent Builder pattern implies that you can forgo invoking any of the WithXyz methods (WithUserType) and just accept all the default values encapsulated in the builder. This again implies that there’s a default user type, which may or may not make sense in that particular domain. Looking at Kelly’s code, UserTypes is an enum (and thus has a default value), so if WithUserType isn’t invoked, the Create method defaults to UserTypes.Admin. That’s a bit too implicit for my taste.
- Since all involved classes are now concrete, the proposed solution isn’t extensibile (and by corollary hard to unit test).
- The builder is essentially a big switch statement.
Both the current implementation and the proposed solution involves passing an enum as a method parameter to a different class. If you’ve read and memorized Refactoring you should by now have recognized both a code smell and the remedy.
Alternative 1a: Make UserType Polymorphic
The code smell is Feature Envy and a possible refactoring is to replace the enum with a Strategy. In order to do that, an IUserType interface is introduced:
public interface IUserType
{ IUserFirstNameModifer CreateUserFirstNameModifier();
}
Usage becomes as simple as this:
var modifier = userType.CreateUserFirstNameModifier();
Obviously, more methods can be added to IUserType to support other update operations, but care should be taken to avoid creating a Header Interface.
While this solution is much more object-oriented, I’m still not quite happy with it, because apparently, the context is a CQRS style architecture. Since an update operation is essentially a Command, then why model the implementation along the lines of a Query? Both Abstract Factory and Factory Method patterns represent Queries, so it seems redundant in this case. It should be possible to apply the Hollywood Principle here.
Alternative 1b: Tell, Don’t Ask
Why have the user type return an modifier? Why can’t it perform the update itself? The IUserType interface should be changed to something like this:
public interface IUserType
{ void CommitUserFirtName(string firstName);
}
This makes it easier for the consumer to commit the user’s first name because it can be done directly on the IUserType instance instead of first creating the modifier.
It also makes it much easier to unit test the consumer because there’s no longer a mix of Command and Queries within the same method. From Growing Object-Oriented Software we know that Queries should be modeled with Stubs and Commands with Mocks, and if you’ve ever tried mixing the two you know that it’s a sort of interaction that should be minimized.
Alternative 2a: Distinguish by Type
While I personally like alternative 1b best, it may not be practical in all situations, so it’s always valuable to examine other alternatives.
The root cause of the problem is that there’s a lot of stored procedures. I want to reiterate that I still think that the absolutely easiest solution would be to generate a SqlCommand from a string template, but given that this article assumes that this isn’t possible or desirable, it follows that code must be written for each stored procedure.
Why not simply define an interface for each one? As an example, to update the user’s first name in the context of being an ‘Admin’ user, this Role Interface can be used:
public interface IUserFirstNameAdminModifier
{ void Commit(string firstName);
}
Similar interfaces can be defined for the other user types, such as IUserFirstNameRestrictedModifier, IUserFirstNameGuestModifier and so on.
This is a very simple solution; it’s easy to implement, but risks violating the Reused Abstractions Principle (RAP).
Alternative 2b: Distinguish by Generic Type
The problem with introducing interfaces like IUserFirstNameAdminModifier, IUserFirstNameRestrictedModifier, IUserFirstNameGuestModifier etc. is that they differ only by name. The Commit method is the same for all these interfaces, so this seems to violate the RAP. It’d be better to merge all these interfaces into a single interface, which is what Kelly’s team is currently doing. However, the problem with this is that the type carries no information about the role that the modifier is playing.
Another alternative is to turn the modifier interface into a generic interface like this:
public interface IUserFirstNameModifier<T>
where T : IUserType
{ void Commit(string firstName);
}
The IUserType is a Marker Interface, so .NET purists are not going to like this solution, since the .NET Type Design Guidelines recommend against using Marker Interfaces. However, it’s impossible to constrain a generic type argument against an attribute, so the party line solution is out of the question.
This solution ensures that consumers can now have dependencies on IUserFirstNameModifier<AdminUserType>, IUserFirstNameModifier<RestrictedUserType>, etc.
However, the need for a marker interface gives off another odeur.
Alternative 3: Distinguish by Role
The problem at the heart of alternative 2 is that it attempts to use the type of the interfaces as an indicator of the roles that Services play. It’s seems that making the type distinct works against the RAP, but when the RAP is applied, the type becomes ambiguous.
However, as Ted Neward points out in his excellent series on Multiparadigmatic .NET, the type is only one axis of variability among many. Perhaps, in this case, it may be much easier to use the name of the dependency to communicate its role instead of the type.
Given a single, ambiguous IUserFirstNameModifier interface (just as in the original problem statement), a consumer can distinguish between the various roles of modifiers by their names:
public partial class SomeConsumer
{ private readonly IUserFirstNameModifier adminModifier;
private readonly IUserFirstNameModifier guestModifier;
public SomeConsumer(
IUserFirstNameModifier adminModifier,
IUserFirstNameModifier guestModifier)
{ this.adminModifier = adminModifier;
this.guestModifier = guestModifier;
}
public void DoSomething()
{ if (this.UseAdmin)
this.adminModifier.Commit("first"); else
this.guestModifier.Commit("first"); }
}
Now it’s entirely up to the Composition Root to compose SomeConsumer with the correct modifiers, and while this can be done manually, it’s an excellent case for a DI Container and a bit of Convention over Configuration.
Conclusion
I’m sure that if I’d spent more time analyzing the problem I could have come up with more alternatives, but this post is becoming long enough already.
Of the alternatives I’ve suggested here, I prefer 1b or 3, depending on the exact requirements.