This article builds on a previous post entitled Encapsulated and strongly-typed access to .NET configuration files. In this example I’ll be adding dependency injection using Castle Windsor.
As per my previous post, the code for this example is in GitHub, here:
https://github.com/stevebarker333/Injected-Encapsulated-Strongly-Typed-Configuration-Files
In this post I’ll assume that you’ve read the previous post, and that you have the existing code base as a starting point. The first step then, is to add Castle Windsor to the project using NuGet. This adds references to each project as follows:
Since dependency injection works by resolving interfaces to types, each encapsulated ConfigurationFile will need to be given an interface by adding IConfigurationFile to each of the two UI projects:
These new interfaces need contain only the properties that are unique to each UI. Access to core properties is achieved via the ICoreConfiguration, as follows:
UI1.Configuration.ConfigurationFile:
using System;
using API.Configuration;
namespace UI1.Configuration
{
public interface IConfigurationFile : ICoreConfiguration
{
string UI1String { get; }
int UI1Int { get; }
Uri UI1Uri { get; }
}
}
UI2.Configuration.ConfigurationFile
using System;
using API.Configuration;
namespace UI2.Configuration
{
public interface IConfigurationFile : ICoreConfiguration
{
string UI2String { get; }
int UI2Int { get; }
Uri UI2Uri { get; }
}
}
The definitions of the ConfigurationFile classes in each UI project need to be adjusted to include these new interfaces, as follows:
public class ConfigurationFile :
API.Configuration.ConfigurationFile, IConfigurationFile,
API.Configuration.ICoreConfiguration
{
...
}
Each UI then gets its own Injector class:
…containing the following code:
UI1.DependencyInjection.Injector:
using API.Configuration;
using Castle.MicroKernel.Registration;
using Castle.Windsor;
using Castle.Windsor.Installer;
using UI1.Configuration;
using API;
namespace UI1.DependencyInjection
{
public static class Injector
{
private static readonly object InstanceLock = new object();
private static IWindsorContainer instance;
public static IWindsorContainer Instance
{
get
{
lock (InstanceLock)
{
return instance ?? (instance = GetInjector());
}
}
}
private static IWindsorContainer GetInjector()
{
var container = new WindsorContainer();
container.Install(FromAssembly.This());
RegisterInjector(container);
RegisterConfiguration(container);
RegisterWidget(container);
return container;
}
private static void RegisterInjector(WindsorContainer container)
{
container.Register(
Component.For<IWindsorContainer>()
.Instance(container));
}
private static void RegisterConfiguration(WindsorContainer container)
{
container.Register(
Component.For<IConfigurationFile, ICoreConfiguration>()
.ImplementedBy(typeof(Configuration.ConfigurationFile))
.LifeStyle.Singleton);
}
private static void RegisterWidget(WindsorContainer container)
{
container.Register(
Component.For<IWidget>()
.ImplementedBy(typeof(Widget))
.LifeStyle.Singleton);
}
}
}
UI2.DependencyInjection.Injector:
using API.Configuration;
using Castle.MicroKernel.Registration;
using Castle.Windsor;
using Castle.Windsor.Installer;
using UI2.Configuration;
using API;
namespace UI2.DependencyInjection
{
public static class Injector
{
private static readonly object InstanceLock = new object();
private static IWindsorContainer instance;
public static IWindsorContainer Instance
{
get
{
lock (InstanceLock)
{
return instance ?? (instance = GetInjector());
}
}
}
private static IWindsorContainer GetInjector()
{
var container = new WindsorContainer();
container.Install(FromAssembly.This());
RegisterInjector(container);
RegisterConfiguration(container);
RegisterWidget(container);
return container;
}
private static void RegisterInjector(WindsorContainer container)
{
container.Register(
Component.For<IWindsorContainer>()
.Instance(container));
}
private static void RegisterConfiguration(WindsorContainer container)
{
container.Register(
Component.For<IConfigurationFile, ICoreConfiguration>()
.ImplementedBy(typeof(Configuration.ConfigurationFile))
.LifeStyle.Singleton);
}
private static void RegisterWidget(WindsorContainer container)
{
container.Register(
Component.For<IWidget>()
.ImplementedBy(typeof(Widget))
.LifeStyle.Singleton);
}
}
}
Note that the technique described in my post entitled Allowing Castle Windsor to resolve two interfaces to the same instance allows the ConfigurationFile type to be accessed using both the API interface ICoreConfiguration and each of the UI interfaces, IConfigurationFile. Note also that the Widget is registered with the dependency injector. This requires some small changes to the Widget and the creation of an interface, IWidget:
using System;
using API.Configuration;
namespace API
{
public class Widget : IWidget
{
public ICoreConfiguration Configuration { get; set; }
public void DoSomething()
{
Console.WriteLine(Configuration.CoreString);
Console.WriteLine(Configuration.CoreInt);
Console.WriteLine(Configuration.CoreUri);
}
}
}
namespace API
{
public interface IWidget
{
void DoSomething();
}
}
Finally, we change the Program classes in the console applications to use the injector, as follows:
using System;
using UI1.Configuration;
using API;
using UI1.DependencyInjection;
namespace UI1
{
public static class Program
{
public static void Main()
{
var configurationFile = Injector.Instance.Resolve<IConfigurationFile>();
Console.WriteLine(configurationFile.UI1String);
Console.WriteLine(configurationFile.UI1Int);
Console.WriteLine(configurationFile.UI1Uri);
var widget = Injector.Instance.Resolve<IWidget>();
widget.DoSomething();
Console.ReadLine();
}
}
}
using System;
using UI2.Configuration;
using API;
using UI2.DependencyInjection;
namespace UI2
{
public static class Program
{
public static void Main()
{
var configurationFile = Injector.Instance.Resolve<IConfigurationFile>();
Console.WriteLine(configurationFile.UI2String);
Console.WriteLine(configurationFile.UI2Int);
Console.WriteLine(configurationFile.UI2Uri);
var widget = Injector.Instance.Resolve<IWidget>();
widget.DoSomething();
Console.ReadLine();
}
}
}
Since the Widget class contains a property called Configuration of type ICoreConfiguration, the dependency injection engine can simply load the correct configuration file object in at run-time, and everything “just works”. Running the application gives exactly the same outputs as the previous non-injected example which means the spirit of the original code has been kept the same:
So, as always, adding dependency injection involves a bit more work, but the benefits (non-brittle, highly testable code to name just two) far outweigh the extra time required.
