Registration by Convention

This topic explains how to use registration by convention to register multiple types with the container automatically by using a set of rules and conventions.

This topic contains the following sections that explain registration by convention:

• TheRegisterTypesMethod
• Identifying the Types to Register Automatically
• Specifying Mapping Behavior
• Specifying Default and Named Registrations
• Specifying the Lifetime Manager to Use
• Specying Injection Behavior
• Specifying Whether to Overwrite Existing Mappings

The RegisterTypes Method

To register multiple types using registration by convention you use the RegisterTypes method. The parameters to this method enable you to specify which types to register, what mappings to create, whether to use named regsitrations, which lifetime manager to use, and any injection members to use. The full signatures of the RegisterTypes extension methods are shown here:

public static IUnityContainer RegisterTypes(
  this IUnityContainer container,
  IEnumerable<Type> types,
  Func<Type, IEnumerable<Type>> getFromTypes = null,
  Func<Type, string> getName = null,
  Func<Type, LifetimeManager> getLifetimeManager = null,
  Func<Type, IEnumerable<InjectionMember>> getInjectionMembers = null,
  bool overwriteExistingMappings)
 
public static IUnityContainer RegisterTypes(
  this IUnityContainer container,
  RegistrationConvention convention,
  bool overwriteExistingMappings = false)

The RegistrationConvention class is an abstract class. You can extend this class to create your own, resusable conventions.

The following sample illustrates using the RegisterTypes method to register multiple types in the Unity container.

using (var container = new UnityContainer())
{
  container.RegisterTypes(
    AllClasses.FromLoadedAssemblies(),
    WithMapping.MatchingInterface,
    WithName.Default,
    WithLifetime.ContainerControlled);
}

Identifying the Types to Register Automatically

Use the types parameter of the RegisterTypes method to specify the list types to register with the container. You can provide this list yourself or use the AllClasses helper class to build the list of types for you. The following table lists the methods of the AllClasses helper class.

Remarks

If you try to use the AllClasses.FromAssembliesInBasePath helper method in a web application, it will not load the assemblies from the bin folder in the web application. To load these assemblies, you should the BuildManager.GetReferencedAssemblies method to obtain a list of assemblies in the bin folder and pass this collection to the AllClasses.FromAssemblies helper method.

Specifying Mapping Behavior

Use the optional getFromTypes parameter of the RegisterTypes method to control what mappings to create in the container for the automatically registered types. The WithMapping helper class provides a set of mapping strategies to use. The following table lists the mapping strategies defined in the WithMapping class.

Specifying Default and Named Registrations

Use the optional getName parameter of the RegisterTypes method to control whether to create named or default registrations in the container. The WithName helper class provides a set of naming strategies to use. The following table lists the naming strategies defined in the WithName class.

Specifying the Lifetime Manager to Use

Use the optional getLifetime parameter of the RegisterTypes method to control which lifetime manager to use for the registrations. The WithLifetime helper class provides a way to select from the available lifetime managers. The following table lists the lifetime managers defined in the WithLifetime class.

Specifying Injection Behavior

Use the optional getInjectionMembers parameter of the RegisterTypes method to control which types the container should inject into the registered types. The container will attempt to inject the injection members whenever you resolve a type from the container. You should be sure that you can inject the injection members into all of types registered in the container. For more information, see the discussion of registration by convention in Chapter 3, “Dependency Injection with Unity” in the Developer’s Guide for Unity.

Specifying Whether to Overwrite Existing Mappings

Use this parameter to control the behavior of the RegisterTypes method if the parameters to this method cause an existing mapping in the container to be overwritten. The existing mapping may have been created by a previous call to to register a type or types or during the current call to the RegisterTypes method. If this parameter is set to false, the method throws an DuplicateTypeMappingException exception if it detects an attempt to overwrite an existing mapping. If the parameter is set to true, the method overwrites the existing mapping with a new mapping based on the other parameters to the method. The default value for this parameter is false.

Next Topic | Previous Topic | Home | Community