Basic to Basics: What is Dependency Inversion? Is it IoC? Part 2
In my previous post on dependency inversion, I talked about what dependency inversion is and gave some examples in the real world.
This post is going to focus much more on the details and how it relates to code.
Back to your code…
Now let’s look at a code example to see how dependency inversion helps us out. Let’s say you are creating a high level module for parsing log files and storing some basic information into a database.
In this case you want to be able to handle several different log files from a number of different sources and write some common data they all share to a database.
One approach to this kind of problem is to have your module handle each kind of log file based on what kind of data and format it contains and where it is. Using this approach, in your module you would handle various kinds of log files based on the interface those individual log files present to you. (When I use interface here, I am not talking about the language construct, but the concept of how we interface with something.)
Using this approach, in our module we might have a switch statement or series of if-else statements that lead us to a different code path depending on what kind of log file we are processing. For one log file we might open up a file on disk, and read a line, then split that line based on some delimiter. For another perhaps we open a database connection and read some rows.
The problem is the log files are defining the interface our higher level code has to use. They are in effect “in control” of our code, because they are dictating the behavior our code must conform to.
We can invert this control, and invert the dependencies by specifying an interface that the log files we process must conform to. We don’t even have to use a language level interface.
We could simply create a data class called LogFile that is the input to our module. Anyone who wanted to use our module would first have to convert their files to our format.
We could also create an ILogFileSource interface that classes could implement to contain the logic of parsing log files from different sources. Our module would depend on ILogFileSource and specify what kind of methods and data it needs to parse the log files instead of the other way around.
The key point here is that our high level module should be controlling the interface (non language construct kind) that the lower level modules need to adhere to instead of being at the whim of the interfaces of each lower level module.
One way to think of this is that lower level modules provide a service to higher level modules. The higher level modules specifies the interfaces for that service and the lower level module provides that service.
One thing I want to point out in this example is that we knew there would be more than one log file source. If we were writing a log file parsing module that was only ever going to work against one source it might not be worth trying to invert this dependency because we wouldn’t see any benefit from doing so. It isn’t very hard for us to write out code as cleanly as possible working with one source and then refactor it later to invert the dependencies once we have additional sources.
Just because you can invert dependencies doesn’t mean you should.
In this case since we are always writing to a database, I don’t feel any particular need to invert our dependency on writing out the log files. However, there is some real value in encapsulating all of our code that interacts with the database into one place, but that is for another post.
Notice we haven’t talked about unit testing yet
You see the problem of dependency inversion and inversion of control has nothing specifically to do with unit testing.
Simply slapping an interface on top of a class and injecting it into another class may help with unit testing, but it doesn’t necessarily invert control or dependencies.
I want to use the log parsing example to illustrate my point. Let’s say we had created our log parser to have a switch statement to handle each type of log file, and now we want to unit test the code.
There is no reason why we can’t create IDatabaseLogFile, ICSVFileSystemLogFile, IEventLogLogFile and IAnNotReallyDoingIoCLogFile, pass them all into the constructor of our LogFileParser as dependencies and then write our unit tests passing in mocks of each.
That in an extreme example for sure, but the point is slapping an interface onto a class does not an IoC make.
We shouldn’t be trying to implement this principle to make it easier to write unit tests. Difficult to write unit tests should give us hints like:
- Our class is trying to do too much
- Our class has lots of different dependencies
- Our class requires a lot of setup to do work
- Our class is just like this other class that does the same thing only for a different input
All of these kinds of hints tell us that we might want to invert control and invert dependencies to improve the overall design of our class, not because it makes it easier to test. (Although it should also make it easier to test.)
Ok, ok, so is dependency inversion the same as inversion of control or what?
Short answer: yes.
It depends on what you mean by control. There are three basic “controls” that can be inverted.
- The control of the interface. (How do these two systems, modules, or classes, interact with each other and exchange data?)
- The control of the flow. (What controls the flow the program? This control inversion happens when we go from procedural to event driven.)
- The control of dependency creation and binding. (This is the kind of inversion of control IoC containers do. This inversion is passing the control of the actual creation of and selection of dependencies to a 3rd party which is neutral to either of the other 2 involved.)
Each of these 3 is a specific form of dependency inversion and may even involve multiple kinds of dependencies being inverted.
So when someone says “inversion of control”, you should be thinking “what control is being inverted here?”
Dependency inversion is a principle that we use in architecting software.
Inversion of control is a specific pattern that is applied to do so.
Most people only think of inversion of control as #3 above, inverting the control of dependency creation and bind. This is where IoC containers and dependency injection take root.
What can we learn from this?
My goal is that we stop grouping the concepts of inversion of control and dependency inversion automatically with dependency injection.
We have learned that dependency inversion is the core principle that guides many of the other practices that have derived from it.
Whenever we apply a pattern we should be looking for the core principle it is tied to and what problem it is helping us solve.
With this base understanding of dependency inversion and inversion of control, we have the prerequisite knowledge to look at dependency injection and understand better what specific problem it tries to solve. (Which I will cover in another post.)