Unity Application Block Methods

The following tables list the methods of the UnityContainer class provided by in the Unity Application Block. The method overloads are grouped into the following categories:

• Constructing and disposing instances of the UnityContainer class
• Registering Type Mappings with the Container
• Registering Existing Object Instances with the Container
• Resolving References to Objects
• Resolving References to All Named Objects of a Specified Type
• Building Up Existing Object Instances
• Managing Container Extensions
• Using the UnityContainer Fluent Interface

Constructing and Disposing Instances of the UnityContainer Class

These methods allow you to create a new default UnityContainer, create a child container that has a specified UnityContainer as its parent, and dispose an existing container.

Registering Type Mappings with the Container

The RegisterType method registers a type with the container. At the appropriate time, the container builds an instance of the type you specify. This could be in response to dependency injection initiated through class attributes or when you call the Resolve method. The lifetime of the object it builds corresponds to the lifetime you specify in the parameters of the method. If you do not specify a value for the lifetime, the type is registered for a transient lifetime—the container creates a new instance on each call to Resolve.

This method is useful for retrieving instances of different objects that implement the same specified interface or that inherit from the same specified base class. The target type for the mapping (the TTo or to parameter in the following table) must inherit from or implement the base type or interface of the source (the TFrom or from parameter in the following table). The LifetimeManager passed to some of the methods controls when object instances are created and disposed. Unity contains default LifetimeManager types for singleton and instance registration. All of these methods return a reference to the UnityContainer upon which the method was called, equivalent to this in C# or Me in Visual Basic.

You can use the RegisterType method to register open generic types. The following code registers a type mapping between an example interface named IRepository and a concrete type named SqlRepository that implements this interface. The code then registers a mapping for the SqlRepository type as an open generic type and shows how you can resolve a specific instance using the IRepository interface as the dependency identifier.

public interface IRepository<TEntity> 
{
  TEntity GetById(int id);
}

public class SqlRepository<TEntity> : IRepository
{
  public TEntity GetById(int id) 
  {
    ... 
  }
}

IUnityContainer myContainer = new UnityContainer();
myContainer.RegisterType(typeof(IRepository<>), typeof(SqlRepository<>));
IRepository<Customer> result = myContainer.Resolve<IRepository<Customer>>();

'Usage
Public Interface IRepository(Of TEntity)
  Function GetById(ByVal id As Integer) As TEntity
End Interface

Public Class SqlRepository(Of TEntity)
  Implements IRepository(Of TEntity)
  Public Function GetById(ByVal id As Integer) As TEntity _
                  Implements IRepository(Of TEntity).GetById
    ... 
  End Function
End Class

Dim myContainer As IUnityContainer = New UnityContainer()
myContainer.RegisterType(GetType(IRepository(Of )), GetType(SqlRepository(Of )))
Dim result As IRepository(Of Customer) = myContainer.Resolve(Of IRepository(Of Customer)())()

Registering Existing Object Instances with the Container

The RegisterInstance method registers with the container an existing instance of a type that you specify, with the lifetime that you specify. The container returns the existing instance during that lifetime. If you do not specify a value for the lifetime, the instance has the default container-controlled lifetime.

Instance registration is similar to type registration, except that you first create the instance directly and then use the RegisterInstance method to add that instance to the container. Therefore, the container does not need to create the instance on the first Resolve request. These methods are useful if you already have an instance of an object you have previously configured. The LifetimeManager passed to some of the methods controls when object instances are created and disposed. Unity contains default LifetimeManager types for singleton and instance registration. The methods return a reference to the UnityContainer upon which the method was called, equivalent to this in C# or Me in Visual Basic.

You can use the RegisterInstance method to register open generic types with non-ambiguous constructors. For example, you can register an existing instance of the Dictionary type. The following code creates and populates a Dictionary, and it then registers the Dictionary using the RegisterInstance method.

IUnityContainer myContainer = new UnityContainer();
Dictionary<string, string> myDict = new Dictionary<string, string>();
myDict.Add("One", "ABC");
myDict.Add("Two", "DEF");
myContainer.RegisterInstance(myDict);

'Usage
Dim myContainer As IUnityContainer = New UnityContainer()
Dim myDict As New Dictionary(Of String, String)()
myDict.Add("One", "ABC")
myDict.Add("Two", "DEF")
myContainer.RegisterInstance(myDict)

Resolving References to Objects

These methods return instances of objects based on the mappings registered with the container. You can request objects using only the type or the type and the registered name.

Resolving References to All Named Objects of a Specified Type

These methods return an enumerable list of instances of objects based on the named (non-default) mappings registered with the container. You can only request a list of objects using the object type. These methods are useful if you have registered multiple object or interface types using the same type but different names.

Building Up Existing Object Instances

These methods pass an existing object through the container and perform injection upon it. These methods are useful when you do not have control of the construction of an instance (for example, in ASP.NET pages or for objects created through XAML), but you still want property or method call injection performed. The methods return the resulting object, although container extensions may add other features that cause the methods to return a different object that is type-compatible with the existing object. For example, a strategy in ObjectBuilder may create and return a proxy for an object instead of the actual object.

Managing Container Extensions

These are methods you can use to add custom extensions to a container and remove all extensions. You can also access the configuration information exposed by an extension. For more information about building and working with container extensions, see Extending and Modifying the Unity Application Block.

Using the UnityContainer Fluent Interface

The API for the Unity container also provides a fluent interface. This means that you can chain method calls in one statement. To use the fluent interface, call all the methods you want, one after the other, in a single statement, as shown in the following code.

IUnityContainer myContainer = new UnityContainer()
   .RegisterType<IMyService, DataService>()
   .RegisterType<IMyService, EmailService>()
   .RegisterType<MyServiceBase, LoggingService>();

'Usage
Dim myContainer As IUnityContainer = New UnityContainer() _
   .RegisterType(Of IMyService, DataService)() _
   .RegisterType(Of IMyService, EmailService)() _
   .RegisterType(Of MyServiceBase, LoggingService)() 

You can use this approach to chain any of the methods of the UnityContainer class when you create the container. For example, you can use any combination of the RegisterType, RegisterInstance, AddExtension, and Configure methods to prepare the container.