A basic introduction to the Unity Application Block

Introduction

With its latest release, the Enterprise Library from Microsoft introduces a new component named Unity. This application block provides an easy path to implement the IoC pattern, and consequently the Dependency Injection pattern.

All the references for the Enterprise Library documentation can be found at the end of the article.

Background

Inversion of Control and Dependency Injection are the key points to understand how Unity works and the benefits of including it in our projects. If you want a deep dive on these patterns: http://martinfowler.com/articles/injection.html.

The scope of this article is writing code that is loosely coupled. Let's examine the following DummyLogger class:

public class DummyLogger
{
    private IWriter _selectedWriter;

    public DummyLogger()
    {
        //The container class is in charge for the initialization of the interface. 
        //the result is a strong dependency between the two objects
        _selectedWriter = new ConsoleWriter();
    }

    public void WriteOutput(string msg)
    {
        _selectedWriter.Write(msg);
    }
}

The first thing that comes to mind to break the relationship between the two objects is to delegate the creation of the class member to someone else:

public class DummyLogger
{
    private IWriter _selectedWriter;

    public void SetWriter(IWriter writer)
    {
        _selectedWriter = writer;
    }

    public void WriteOutput(string msg)
    {
        _selectedWriter.Write(msg);
    }
}

Nothing new until now. This can be interpreted as a trivial implementation of the IoC pattern. The contained object is no more controlled by its container class.

But what if we don't care about the real implementation of the IWriter interface ? Here's where Unity and Dependency Injection comes. The concrete implementation of the class member will be "injected" by Unity depending on its configuration. The first thing we need to do is expose the class/interface with its get/set methods and mark it with the [Dependency] attribute to make it visible to the application block.

public class DummyLogger
{

    private IWriter _selectedWriter;

    public void SetWriter(IWriter writer)
    {
        _selectedWriter = writer;
    }

    public void WriteOutput(string msg)
    {
        _selectedWriter.Write(msg);
    }
}

Behind the scenes, each class/interface decorated with the [Dependency] attribute will be created according to the Unity container's configuration. This can be done programmatically or via the .config file.

<type type="George2giga.TestUnity.Library.IWriter,George2giga.TestUnity.Library" 
   mapTo="George2giga.TestUnity.Library.ConsoleWriter,George2giga.TestUnity.Library" />

Using the code

Given below is a basic implementation of Unity. Here's the class diagram of our sample application:

IWriter, the interface is shared between the logging providers:

public interface IWriter
{
    void Write(string msg);
}

Of the three logging providers, depending on the configuration, one of them will be "injected" to create the IWriter instance:

public class ConsoleWriter : IWriter
{
    #region IWriter Members

    public void Write(string msg)
    {
        Console.WriteLine(msg);
        Console.ReadLine();
    }

    #endregion
}

public class FileWriter : IWriter
{
    #region IWriter Members

    public void Write(string msg)
    {
        using (StreamWriter streamWriter = 
               new StreamWriter("c:\\TestUnity.txt",true))
        {
            streamWriter.WriteLine(msg);
        }
    }
    #endregion
}

public class EventViewerWriter : IWriter
{
    #region IWriter Members

    public void Write(string msg)
    {
        EventLog.WriteEntry("TestUnity", msg, 
                            EventLogEntryType.Information);
    }

    #endregion
}

The logging class contains the dependency property:

public class DummyLogger
{
    private IWriter selectedWriter;

    [Dependency]
    public IWriter SelectedWriter
    {
        get { return selectedWriter; }
        set { selectedWriter = value; }
    }

    public void WriteOutput(string msg)
    {
        selectedWriter.Write(msg);
    }
}

The entry point of the application is responsible for the initialization of the Unity container:

class Program
{
    static void Main(string[] args)
    {
        IUnityContainer container = new UnityContainer();
        UnityConfigurationSection section = 
          (UnityConfigurationSection)ConfigurationManager.GetSection("unity");
        section.Containers.Default.Configure(container);
        DummyLogger dummyLogger = container.Resolve<DummyLogger>();
        dummyLogger.SelectedWriter.Write("Hello");}
}

Here is the App.config:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <configSections>
      <section name="unity" 
         type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection, 
               Microsoft.Practices.Unity.Configuration" />
    </configSections>
    <unity>
      <containers>
        <container>
          <types>
            <type 
               type="George2giga.TestUnity.Library.IWriter,George2giga.TestUnity.Library" 
               mapTo="George2giga.TestUnity.Library.ConsoleWriter,
                      George2giga.TestUnity.Library" />
          </types>
        </container>
      </containers>
    </unity>
</configuration>

Points of interest

Design patterns are without doubt a very interesting argument. With Unity, we are able to implement two of them in a very easy way. Dependency Injection allows us to create code that is decoupled, where we can create dependencies without hard-coding anything on our project.

References

• Unity: http://msdn.microsoft.com/en-us/library/cc440954.aspx