Continuing from [part 1](/blog/ioc-demystified-pt-1) of this 2 part series, we'll conclude this series with building a simple dependency injection container as well as putting the tutorial together as a whole. ## The container For this section, we'll create our own simple dependency injection container, purely for educational reasons. In the real world, I would advise to use a battle-tested solution, as there are many to choose from, such as StructureMap, Unity, DryIoC, and many more. I will include a section at the end, listing my personal recommendations. To build our own container, we'll need to list what we would like our container to accomplish: 1. Must be able to register service *interfaces* to service *implementations* mappings into a managed registry Should be able to utilize some basic validations, such as ensuring registered implementations derive from the corresponding interfaces 2. Must be able to request a service interface and container will populate implementation dependencies from managed registry Will require [*generics*](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/generics/) and [*System.Reflection*](https://docs.microsoft.com/en-us/dotnet/framework/reflection-and-codedom/reflection) to obtain type information from constructors, as well as dynamically creating instances from type information. I tend to start with the more complicated parts first and make a proof-of-concept. So lets start with the second item of our requirements. In this sample, I'll create a method called CreateDefault and the purpose is to be able to accept a generic of T, constrained to only allow class types, and obtain the [default constructor](https://docs.microsoft.com/en-us/dotnet/api/system.type.getconstructor), [invoke it](https://docs.microsoft.com/en-us/dotnet/api/system.reflection.constructorinfo.invoke), and return the new instance (or null if there was no default constructor). **Example** ```c# using System; internal class Example { public override string ToString() => "Hello World"; } internal static class Program { private static T CreateDefault() where T : class { var defaultConstructor = typeof(T) .GetConstructor(Array.Empty()); return defaultConstructor ?.Invoke(Array.Empty()) as T; } private static void Main() { var example = CreateDefault(); Console.WriteLine(example); } } ``` Now that we have a basic proof-of-concept, let's build an interface for our container. ```c# public interface IContainer { void Register() where TServiceValue : class, TServiceKey where TServiceKey : class; TService Resolve() where TService : class; object Resolve(Type type); } ``` Let's start stubbing out our implementation. Since we'll be using the *TServiceKey* as a means to retrieve the *TServiceValue*, the mechanism that made the most sense was to store our mappings as [*System.Type*](https://docs.microsoft.com/en-us/dotnet/api/system.type) into a [dictionary](https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.dictionary-2). This way, we can just use *TServiceKey* directly as a key, and ensure that there are no overlapping records stored. ```c# using System; using System.Collections.Generic; using System.Linq; public class Container : IContainer { private readonly Dictionary _registry; public Container() { _registry = new Dictionary(); } public void Register() where TServiceValue : class, TServiceKey where TServiceKey : class { _registry.Add(typeof(TServiceKey), typeof(TServiceValue)); } // ... } ``` For the *Resolve* method, we'll start off by building two separate methods, a generic method and a non-generic method. The bulk of the work will exist in our non-generic method. Breaking down the steps: 1. This method will need to be used as a recursive method. The *type* parameter passed in will either represent the initial TService key we were trying to resolve, or it will be a nested dependency from a series of constructor parameters. 2. Whether we were able to retrieve a value from the registry or default to the parameter, we will retrieve the corresponding constructors of that type and attempt to resolve the constructor parameter types from the registry. Each constructor parameter will use recursion to call this method until all nested parameters within are resolved. 3. Once a type's constructor parameters are resolved, we will attempt to invoke the first available constructor that was resolved, or call the default constructor and return the result. ```c# // ... public TService Resolve() where TService : class { var type = typeof(TService); return Resolve(type) as TService; } public object Resolve(Type type) { var resolvedType = _registry.TryGetValue(type, out var registeredType) ? registeredType : type; var resolvedConstructorArgs = resolvedType .GetConstructors() .Select(ctorInfo => KeyValuePair.Create( ctorInfo, ctorInfo .GetParameters() .Select(parameter => Resolve(parameter.ParameterType)) .ToArray())) .Where(parameters => parameters.Value.Any()) .ToList(); if (resolvedConstructorArgs.Any()) { var (constructor, constructorArgs) = resolvedConstructorArgs.FirstOrDefault(); return constructor.Invoke(constructorArgs); } return resolvedType.GetConstructor(Array.Empty()).Invoke(Array.Empty

Danl Barron