Dependency Injection / Inversion of Control–A Concrete Example-Roll your own

 Who’s the wizard behind the curtain?

I’ve been reading Martin Fowler’s post about Inversion of Control / Dependency Injection at https://www.martinfowler.com. I looked long and hard for very simple examples that were easy to follow. I wanted to explore how they work, not just how to use an existing library.

How exactly does Dependency Injection work? It seemed rather mysterious to me from the implementation point of view. Some people look at a compiler and think, “Wow, that’s cool how it could translate source code into machine code.”

I’m the type of person that wants to know how exactly it works.

So in this post I show you how you might start to think about building a Dependency Injection container.   

I focus on code here. If you want to read all the friendly narrative, here is Martin’s post:

The difficult way to learn how things work – using pre-built libraries

But the basic guidance is to use pre-built libraries. Microsoft historically supported the enterprise library, Unity. There is also Castle Windsor as an available library.

Roll your own

But I was curious. What could I create in C# that mimicked the basic principles using some of features of C# just to illustrate the basic point with a simple, concrete example?

I’m borrowing heavily from Martin Fowler here, since he is highly regarded in software architecture space.

The definition in 2 sentences

In the Dependency Injection pattern, this decision is delegated to the "injector" which can choose to substitute different concrete class implementations of a dependency contract interface at run-time rather than at compile time. Being able to make this decision at run-time rather than compile time is the key advantage of dependency injection.

Conventional OO – The dependent object is in control

With conventional software development the dependent object decides for itself what concrete classes it will use.

Referring to Figure 1, this means the constructor for TextFileLister decides what concrete classes it will use.

The dependent object will typically choose from among the two classes in Figure 2

Figure 2 demonstrates that TextFileLister could choose either CommaTextFileReader or TabTextFileReader to process and read text files.

This is where the term Dependency Injection comes into play.

Figure 1 – The Dependency Injection Diagram

Figure 2 – The interface and the corresponding implementation

Let the assembler (MutableContainer) make the decision

The basic idea of the Dependency Injection sample we are writing is to have a separate object, an assembler, that populates a field in the TextFileLister class with an appropriate implementation for the IFileReader interface, resulting in a dependency diagram along the lines of Figure 1.

In a nutshell, the assembler makes the call. It chooses either CommaTextFileReader or TabTextFileReader. The key point is that TextFileLister doesn’t make the decision.

Figure 3 illustrates the Visual Studio project I created to demonstrate the points.

Figure 3 – Visual Studio

The code

Let’s start to explore the code. We’ll start with the basic objects and work our way up to the assembler.

Figure 4 is pretty straightforward and shows us the interface used by the two implementing classes in Figures 5 and 6. This is critical that we have an interface. Interfaces allow us to swap out the implementations without runtime or compile time errors.

Figure 4: IFileReader.cs - The interface to CommaTextFileReader and TabTextFileReader

 using System;
namespace IocForDummies
{
    interface IFileReader
    {
        void Close();
        int CountColumns();
        int CountLines();
        void FillData(string[,] data);
        bool HasData();
        void ReadLine(string s);
    }
}

This is one of the two implementation files that use IFileReader. The code is self-explanatory. It opens a text file and parses it out. In this case it is simply parsing a comma-delimited text file.

Figure 5: CommaTextFileReader.cs - Reads and parses CommaDelimitedData.txt, using commas as the delimeter

 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;

namespace IocForDummies
{
    public class CommaTextFileReader : IocForDummies.IFileReader
    {
        FileStream fsReader = null;
        StreamReader streamReader = null;

        public CommaTextFileReader(string path)
        {
            fsReader = File.Open(path, FileMode.Open);
            streamReader = new StreamReader(fsReader, System.Text.Encoding.ASCII);

        }
        public void ReadLine(string s)
        {
            s = streamReader.ReadLine();
        }
        public bool HasData()
        {
            return (streamReader.EndOfStream == false);
        }
        public void FillData(string[,] data)
        {
            string[] s = null;
            for (int i = 0; i < data.GetLength(0); i++)
            {
                s = streamReader.ReadLine().Split(',');
                for (int j = 0; j < data.GetLength(1); j++)
                {
                    if (s[j] != "")
                        data[i, j] = s[j];
                }
            }
        }
        public int CountLines()
        {
            int i = 0;
            string s = null;
            while ((s = streamReader.ReadLine()) != null)
            {
                i++;
            }
            fsReader.Seek(0, SeekOrigin.Begin);
            streamReader.DiscardBufferedData();
            return i;
        }
        public int CountColumns()
        {
            string s = streamReader.ReadLine();
            string[] columns = s.Split(',');
            fsReader.Seek(0, SeekOrigin.Begin);
            streamReader.DiscardBufferedData();
            return columns.Length;
        }
        public void Close()
        {
            streamReader.Close();
            fsReader.Close();
        }
    }
}

  

TabTextFileReader

This is the second of the two implementation files that use IFileReader. The code is self-explanatory. It opens a text file and parses it out. In this case it is simply parsing a tab-delimited text file.

Figure 6: TabTextFileReader.cs - Reads and parses TabDelimitedData.txt, using tabs as the delimeter

 public class TabTextFileReader : IocForDummies.IFileReader
{
    FileStream fsReader = null;
    StreamReader streamReader = null;

    public TabTextFileReader(string path)
    {
        fsReader = File.Open(path, FileMode.Open);
        streamReader = new StreamReader(fsReader);

    }
    public void ReadLine(string s)
    {
        s = streamReader.ReadLine();
    }
    public bool HasData()
    {
        return (streamReader.EndOfStream == false);
    }
    public void FillData(string[,] data)
    {
        string[] s = null;
        for (int i = 0; i < data.GetLength(0); i++)
        {
            s = streamReader.ReadLine().Split(',');
            for (int j = 0; j < data.GetLength(1); j++)
            {
                if (s[j] != "")
                    data[i, j] = s[j];
            }
        }
    }
    public int CountLines()
    {
        int i = 0;
        string s = null;
        while ((s = streamReader.ReadLine()) != null)
        {
            i++;
        }
        fsReader.Seek(0, SeekOrigin.Begin);
        streamReader.DiscardBufferedData();
        return i;
    }
    public int CountColumns()
    {
        string s = streamReader.ReadLine();
        string[] columns = s.Split(',');
        fsReader.Seek(0, SeekOrigin.Begin);
        streamReader.DiscardBufferedData();
        return columns.Length;

    }
    public void Close()
    {
        streamReader.Close();
        fsReader.Close();
    }
}

The class in Figure 7 (TextFileLister) simply calls the code in the implementation files in Figures 5 and 6. The key point is IFileReader can contain either CommaTextFileReader or TabTextFileReader, depending on the assembler’s wishes. This is the key point in this post – that TextFileLister doesn’t determine the classes it will use.

Figure 7: TextFileLister.cs - The dependent object that uses the interface IFileReader. The TextFileLister will rely on CommaTextFileReader or TabTextFileReader, depending what the assembler (MutableContainer) decides

 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace IocForDummies
{
    class TextFileLister
    {
        IFileReader reader = null;
        string[,] data = null;

        public TextFileLister(IFileReader fileReader)
        {
            reader = fileReader;
        }
        public void ReadData()
        {
            int lines = reader.CountLines();
            int columns = reader.CountColumns();
            data = new string[lines, columns];
            reader.FillData(data);
        }
        public void ShowData()
        {
            for (int i = 0; i < data.GetLength(0); i++) 
            {
                for (int j = 0; j < data.GetLength(1); j++)
                    Console.Write(string.Format("[{0}]", data[i, j]));
                Console.WriteLine("");
            }
        }
        ~TextFileLister()
        {
            reader.Close();

        }
    }
}

The Assembler – Where the magic happens

Figure 8 has some tricky code. The _typeToCreateCode field is a dictionary. The dictionary contains object creation code that is mapped to an object type. For example, we can ask the MutableContainer code to go and retrieve the previously added constructor code for any type. Figure 9 illustrates how we add entries to the Dictionary _typeToCreateCode field.

Using lamdas, it is very easy to pass in a type and a delegate. For example, the AddComponent(CreateCode createCode) gets called in Program.cs, where a type and some object construction code gets passed in.

The code in Figure 8 allows you to later retrieve an object type and it’s creation code at runtime, supporting the whole Dependency Injection paradigm. The MutableContainer code below is at the heart of the dependency injection capabilities.

Notice that AddComponent() will replace an existing object, not necessarily always add one. This is important because mutableContainer.AddComponent could either pass in CommaTextFileReader or TabTextFileReader, but not both.

Figure 8: MutableContainer.cs - The assembler which will build construct objects at runtime. In a nutshell, it can be used to use either CommaTextFileReader or TabTextFileReader

 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace IocForDummies
{
    public class MutableContainer
    {
        public delegate object CreateCode();

        private readonly Dictionary<Type, CreateCode> _typeToCreateCode
                        = new Dictionary<Type, CreateCode>();

        public T Create<T>()
        {
            // Do a look up in the dictionary. Use the object type to do the lookup "typeof(T)".
            // The lookup will yield the object creation code.
            // Execute the object creation code.
            return (T)_typeToCreateCode[typeof(T)]();
        }
        internal void AddComponent<T>(CreateCode CreateCode)
        {
            // Remove previous entry, if it exists
            if (_typeToCreateCode.ContainsKey(typeof(T)))
                _typeToCreateCode.Remove(typeof(T));
            // Add the new entry
            _typeToCreateCode.Add(typeof(T), CreateCode);
        }
    }
}

Using MutableContainer

This is the code where the assembler is called to perform its work.

The key point of Dependency Injection is that the assembler determines how the TextFileLister gets constucted, whether TextFileLister uses CommaTextFileReader or TabTextFileReader. TextFileLister does not determine how it reads text files.

Figure 9: Program.cs – The main driver loop which illustrates our points

 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace IocForDummies
{
    class Program
    {
        static void Main(string[] args)
        {
            string commaFileName = Environment.CurrentDirectory +
                                        @"..\..\..\" + @"CommaDelimitedData.txt";

            string tabFileName = Environment.CurrentDirectory +
                                        @"..\..\..\" + @"TabDelimitedData.txt";


            MutableContainer mutableContainer = new MutableContainer();
            
            mutableContainer.AddComponent<IFileReader>(() =>
            {
                // Embeded object is of type CommaTextFileReader
                IFileReader fileReader= new CommaTextFileReader(commaFileName);
                return fileReader;
            });

            mutableContainer.AddComponent<TextFileLister>(() =>
            {
                IFileReader fileReader = mutableContainer.Create<IFileReader>();
                return new TextFileLister(fileReader);
                
            });

            TextFileLister customCommaDataReader = mutableContainer.Create<TextFileLister>();
            customCommaDataReader.ReadData();
            customCommaDataReader.ShowData();

            // Now read a tab delimited file
            mutableContainer.AddComponent<IFileReader>(() =>
            {
                // Embeded object is of type TabTextFileReader
                IFileReader fileReader = new TabTextFileReader(tabFileName);
                return fileReader;
            });

            TextFileLister customTabDataReader = mutableContainer.Create<TextFileLister>();
            customTabDataReader.ReadData();
            customTabDataReader.ShowData();
        }
        }
}

Figure 10 – The text files

Conclusion

What I just described is Constructor Injection. There are 2 other types of injection, Setter Injection and Interface Injection. Martin Fowler describes the other forms of DI in at his blog.

Download for Azure SDK