Unity3.0基於約定的自動注冊機制

前文《Unity2.0容器自動注冊機制》中，介紹了如何在 Unity 2.0 版本中使用 Auto Registration 自動注冊機制。在 Unity 3.0 版本中（2013年），新增了基於約定的自動注冊機制（Registration By Convention），以使 Unity 容器的裝配過程變得更加簡單，並且減少冗余代碼。

Convention over Configuration

Convention over Configuration 是現如今非常流行的設計風格，很多框架都在嘗試采納該風格，包括 ASP.NET MVC。簡要的說就是需要依賴某種預先定義的約定，類似於文件、目錄的命名，類或者系統依據約定做指定的事等。例如，在 ASP.NET MVC 中，所有 Controller 都必須包含 “Controller” 后綴，這樣框架才能找到該 Controller 並進行初始化。

約定風格使開發人員的生活變得輕松多了，我們無需再耗費精力在繁雜的配置上，轉而采用一些簡單的約定規則。

例如，有一個時常出現的模式。我們定義一個類 Foo 來作為接口 IFoo 的默認實現。在匈牙利命名法的編程風格中，標記 “I” 通常是接口的第一個字母。利用這一點，我們可以設定一個命名約定。

  public interface IConvention
  {
  }

  public class Convention : IConvention
  {
  }

基於此約定，我們可以掃描整個程序集來查找滿足約定的接口和類，並自動注冊進 Unity 容器。

Registration by Convention

早在2009年，Jeremy Miller 在 StructureMap 2.5 版本中即已引入了基於約定的自動注冊機制，通過擁抱 Convention over Configuration 設計范式來降低使用 Configuration 的開銷。

同年，Derek Greer 為 Unity 2.0 增加了 Convention-based Registration Extension 擴展。而微軟官方直到2013年 Unity 3.0 才增加此功能。

基於約定的自動注冊機制目的在於簡化類型注冊過程，減少類型注冊代碼。比起無數的 “container.RegisterType<IFoo, Foo>()”，可以直接通過掃描程序集，依據一些既定的規則來自動完成類型注冊。

      using (var container = new UnityContainer())
      {
        container.RegisterTypes(
           AllClasses.FromAssembliesInBasePath(),
           WithMappings.FromMatchingInterface,
           WithName.Default,
           WithLifetime.ContainerControlled);
      }

支持的 Conventions

Convention 必須指明哪些可用類型應該被映射進 Unity 容器中。當前的 Unity 3.0 中的可用約定支持如下規則：

1. 識別掃描被注冊類型所在的程序集：可以使用提供的程序集列表，使用當前已加載的程序集列表，使用在當前應用程序目錄中的所有程序集列表。可以進一步通過類型的名稱、后綴或者其他規則進行過濾，並且支持 LINQ 語法。這一步准備了可能被注冊的類型列表。默認情況下，所有系統程序集將被自動過濾掉。當然，也不是非要使用幫助類中所提供的類型加載方式，可以使用一個方法來獲取類型的枚舉集合，或者甚至直接使用一個數組。
2. 可選項，指定哪些類型（典型的是接口或者抽象類）需要通過容器來映射到步驟 1 中的類型。目前的約定包括：
• 映射哪些遵循命名約定的類型。例如類 Foo 和 接口 IFoo 。
• 映射類型實現的所有接口。
• 映射類型實現的所有接口，並且這些接口必須與類型定義在同一程序集內。
3. 可選項，指定是否使用命名注冊（Named Registration）。也可以使用類型的名稱作為注冊名稱。
4. 可選項，指定注冊類型時使用哪種生命周期管理器（Lifetime Manager）。
5. 可選項，確定是否有類型成員需要注入（Injected Parameter）。

所有約定通過 RegisterTypes 方法來表述：

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 = false);

RegisterTypes 方法簽名描述：

Parameter	Description
Types	This parameter is an enumerable collection of types that you want to register with the container. These are the types that you want to register directly or create mappings to. You can create this collection by providing a list of types directly or by using one of the methods of the built-in AllClasses helper class: for example, the method FromLoadedAssemblies loads all of the available types from the currently loaded assemblies. You can use LINQ to filter this enumeration.
getFromTypes	This optional parameter identifies the types you want to map from in the container. The built-in WithMappings helper class provides several options for this mapping strategy: for example, theMatchingInterface property creates mappings where there are interfaces and implementations that follow the naming conventionITenant and Tenant.
getName	This optional parameter enables you to control whether to create default registrations or named registrations for the types. The built-in helper class WithName, enables you to choose between using default registrations or named registrations that use the type name.
getLifeTimeManager	This optional parameter enables you to select from the built-in lifetime managers.
getInjectionMembers	This optional parameter enables you to provide definitions for any injection members for the types that you are registering.
overwriteExistingMappings	This optional parameter enables you to control how the method behaves if it detects an attempt to overwrite an existing mapping in the Unity container. By default, the RegisterTypes method throws an exception if it detects such an attempt. If this parameter is true, the method silently overwrites an existing mapping with a new one based on the values of the other parameters.

簡單示例：

      var container = new UnityContainer();

      container.AddNewExtension<Interception>();
      container.RegisterTypes(
        AllClasses.FromLoadedAssemblies().Where(
          t => t.Namespace == "OtherUnitySamples"),
        WithMappings.FromMatchingInterface,
        getInjectionMembers: t => new InjectionMember[]
        {
          new Interceptor<VirtualMethodInterceptor>(),
          new InterceptionBehavior<LoggingInterceptionBehavior>()
        });

自定義約定類

Unity 通過提供注冊約定抽象類 RegistrationConvention 來提供擴展性。

  public abstract class RegistrationConvention
  {
    public abstract Func<Type, IEnumerable<Type>> GetFromTypes();
    public abstract Func<Type, IEnumerable<InjectionMember>> GetInjectionMembers();
    public abstract Func<Type, LifetimeManager> GetLifetimeManager();
    public abstract Func<Type, string> GetName();
    public abstract IEnumerable<Type> GetTypes();
  }

我們可以自定義實現 RegistrationConvention ：

  class CustomizedConvention : RegistrationConvention
  {
    public override Func<Type, IEnumerable<Type>> GetFromTypes()
    {
      return t => t.GetInterfaces();
    }

    public override Func<Type, IEnumerable<InjectionMember>> GetInjectionMembers()
    {
      return null;
    }

    public override Func<Type, LifetimeManager> GetLifetimeManager()
    {
      return t => new ContainerControlledLifetimeManager();
    }

    public override Func<Type, string> GetName()
    {
      return t => t.Name;
    }

    public override IEnumerable<Type> GetTypes()
    {
      yield return typeof(Foo);
      yield return typeof(Bar);
    }
  }

      var container = new UnityContainer();
      container.RegisterTypes(new CustomizedConvention());

顯示已注冊類型信息

可以通過顯示枚舉容器的 Registrations 屬性來獲得所有的注冊信息。

  class Program
  {
    static void Main(string[] args)
    {
      var container = new UnityContainer();
      container.RegisterTypes(new CustomizedConvention());

      Console.WriteLine("Container has {0} Registrations:",
        container.Registrations.Count());
      foreach (ContainerRegistration item in container.Registrations)
      {
        Console.WriteLine(item.GetMappingAsString());
      }

      Console.ReadKey();
    }
  }

  public interface IFoo { }
  public class Foo : IFoo { }
  public interface IBar { }
  public class Bar : IBar { }

  static class ContainerRegistrationsExtension
  {
    public static string GetMappingAsString(
      this ContainerRegistration registration)
    {
      string regName, regType, mapTo, lifetime;

      var r = registration.RegisteredType;
      regType = r.Name + GetGenericArgumentsList(r);

      var m = registration.MappedToType;
      mapTo = m.Name + GetGenericArgumentsList(m);

      regName = registration.Name ?? "[default]";

      lifetime = registration.LifetimeManagerType.Name;
      if (mapTo != regType)
      {
        mapTo = " -> " + mapTo;
      }
      else
      {
        mapTo = string.Empty;
      }
      lifetime = lifetime.Substring(
        0, lifetime.Length - "LifetimeManager".Length);
      return String.Format(
        "+ {0}{1}  '{2}'  {3}", regType, mapTo, regName, lifetime);
    }

    private static string GetGenericArgumentsList(Type type)
    {
      if (type.GetGenericArguments().Length == 0) return string.Empty;
      string arglist = string.Empty;
      bool first = true;
      foreach (Type t in type.GetGenericArguments())
      {
        arglist += first ? t.Name : ", " + t.Name;
        first = false;
        if (t.GetGenericArguments().Length > 0)
        {
          arglist += GetGenericArgumentsList(t);
        }
      }
      return "<" + arglist + ">";
    }
  }

輸出結果：

參考資料

• Dependency Injection with Unity
• Unity Configuration - Registration by Convention