Home » Software Architecture » Why Is It Called “Inversion of Control”?

Why Is It Called “Inversion of Control”?

CHIL0007There is a guy I’m working with who is trying to wrap his head around design principles.  He’s been watching a lot of PluralSight videos.  As he was processing information about Inversion of Control, he asked the natural question I’ve never actually considered before.  “Why is it called Inversion of Control?  Normally, when you talk about ‘Inversion’ you are talking about reversing something or negating something.  That isn’t what we are doing here.”

What Is Inversion of Control?

So, let’s start with a definition of what Inversion of Control is.  And let’s start the definition by explaining what it isn’t.

In the old days, back when I started programming.  We had this thing called “Procedural Programming.” Control of your application flowed from beginning to end with looping to take care of any kind of waiting that needed to take place.  Martin Fowler describes this using an illustration that is version similar to a basic “How to program in C#” console application that is in the beginning of most beginner programming books.

Let’s consider a simple example. Imagine I’m writing a program to get some information from a user and I’m using a command line enquiry. I might do it something like this

  puts 'What is your name?'
  name = gets
  puts 'What is your quest?'
  quest = gets

In this interaction, my code is in control: it decides when to ask questions, when to read responses, and when to process those results.

What Inversion of Control does is that it puts something other than the main code in charge of doing critical parts of the program so that those other parts of the program can be swapped out by the person implementing the code.

Examples of Inversion of Control

If you’ve ever written a WebForms or Windows Forms application, you’ve already experience inversion of control.

OnPageLoad() or OnFormLoad()

You have probably never even given this much thought.  You think these two methods are where your code starts.  But the reality is, the code started long before these methods ever got called.  The thing that is in control is the .NET framework.  You’ve created a delegate that gets called by the framework so that your page or form does what you want it to.  Without this inversion of control, you would have to write a whole lot more code.

Event Handlers

While you might think of OnPageLoad and OnFormLoad as event handlers, the way they are implemented are more like virtual functions.  Event handlers, on the other hand, are a specific type of delegate that say, “When this thing happens, let me know about it.”  The code that fires the event doesn’t even really care what you do during the event.  Again, the control has been “Inverted” because there is a lot of code that is running that you have no control over and probably have no knowledge of.

Virtual Functions

One of my favorite methods of inverting control is to use virtual functions.  I can have a parent class that controls the flow of the program that calls various virtual functions in order.  But my child class can provide the implementation of the functions to make them do various things.  I used this, at one time in the past, to create a framework for submitting links to various bookmarking sites.  They all worked essentially the same way, all I had to do was implement the specific details for each site while 80% of my code stayed the same in the base class.

Delegates or Callback Functions

Another common way of implementing inversion is by using delegates or callbacks.  This work in a similar way to virtual functions expect that the functions are typically passed in to a method.  Much of the current implementation of JavaScript uses this method of inverting control as a primary pattern (but not limited to it as the only way.)

Dependency Injection

I’ve talked about Dependency Injection before.  Again, it is another way of delegating control to something other than the code that has main control.  What I want to make special note of here, though, is that Inversion of Control is not Dependency Injection but Dependency Injection is a form of Inversion of Control.  I think this is where most of the confusion about Inversion of Control comes from.  Most of the literature that talks about Inversion of Control talks about it at the same time they are talking about Dependency Injection.  As though the two concepts were the same.

Why Inversion of Control Matters

Finally, I want to talk for a bit about why Inversion of Control matters.  Because, for me, it is a lot more important that we understand what we are trying to achieve than it is that we’ve given it the right name or that we even know what name to call it.  All of the examples I’ve provided are things you’ve probably done in your code.  Some of them you’ve done without even knowing you were doing them.  But think about the alternative of not doing them.

First, your code would be a lot harder to maintain.  Just think of how hard it would be to write a web site and maintain it if you had to write code that handled all of the work that happens for you behind the scenes.

Second, it makes the code more loosely coupled.  And by doing that, it makes the code testable AND it makes the code more flexible and easy to change in the future.

Maybe instead of calling it Inversion of Control it should have been called Delegation of Control.  Either way, the concept is to remove as much code as possible from our main controlling code and give the implementation responsibility to something else that can be swapped in without having to change the main loop.

Other Places Talking About Inversion of Control:


Other post in Software Architecture

Related Post

  • The Myth of Sloppy CodeThe Myth of Sloppy Code Tightly coupled code runs faster. Tightly coupled code is easier to write. Test Driven Development increases development time. Test Driven Development negatively impacts code […]
  • Are You Average or Awesome? 9 Ways to Improve.Are You Average or Awesome? 9 Ways to Improve. The story goes that there were two men, Joe and Frank, who were camping out in the woods when a bear showed up in the camp.  Terrified, they decided the best they could do would be to stay […]
  • Are You Thinking Clearly About Your Architectural Choices?Are You Thinking Clearly About Your Architectural Choices? Recently someone asked me where the business rules should go in an MVC framework.  The Model or the Controller?This reminded me of a post I wrote when ASP.NET MVC was first […]
  • Software Architecture without Test Driven Development is DANGEROUS!Software Architecture without Test Driven Development is DANGEROUS! I’ve had two incidents recently that have shown me how TDD impacts Software Architecture.  Both of these are with code I’m working on. What Software Architecture Might Do Software […]
  • 4 Reasons to Write Loosely Coupled Code4 Reasons to Write Loosely Coupled Code This past week I got into a small discussion about the importance of loosely coupled code.  Specifically, I was looking at event handler code that did nothing more than change the size of […]

About Dave Bush

Dave Bush is a Full Stack ASP.NET developer focusing on ASP.NET, C#, Node.js, JavaScript, HTML, CSS, BootStrap, and Angular.JS.Does your team need additional help in any of the above? Contact Dave today.

One Pingback/Trackback