依赖注入容器Unity介绍

Unity是微软团队开发的一个轻量级，可扩展的依赖注入容器，为松散耦合应用程序提供了很好的解决方案，支持构造器注入，属性注入，方法注入。

同样根据控制反转IOC与依赖注入DI中的例子

interface IDal { void save(); } class SqlServerDal : IDal { public void save() { Console.WriteLine("SqlServer save."); } } class OracleDal : IDal { public void save() { Console.WriteLine("Oracle save."); } }

Unity的实现如下：

IUnityContainer container = new UnityContainer(); container.RegisterType(); var dal = container.Resolve();//这是得到OracleDal的实例。 dal.save();

1、创建容器

IUnityContainer container = new UnityContainer();

2、注册映射

a) 代码方式注册映射：

container.RegisterType();

RegisterType有以下几个重载方法：
RegisterType<TFrom, TTo>( )
RegisterType<TFrom, TTo>(LifetimeManager lifetime)
RegisterType<TFrom, TTo>(String name)
RegisterType<TFrom, TTo>(String name, LifetimeManager lifetime)
RegisterType<T>(LifetimeManager lifetime)
RegisterType<T>(String name, LifetimeManager lifetime)
RegisterType(Type from, Type to)
RegisterType(Type from, Type to, String name)
RegisterType(Type from, Type to, LifetimeManager lifetime)
RegisterType(Type from, Type to, String name, LifetimeManager lifetime)
RegisterType(Type t, LifetimeManager lifetime)
RegisterType(Type t, String name, LifetimeManager lifetime) 

b) 通过配置方式注册映射：

UnityConfigurationSection section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity"); config文件配置如下：

配置方式完整代码：

IUnityContainer container = new UnityContainer();UnityConfigurationSection section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");section.Configure(container);var dal = container.Resolve();//这是得到OracleDal的实例。 dal.save();

3、获取对象实例

var dal = container.Resolve();//这是得到OracleDal的实例。

可以通过方法ResolveAll来得到所有注册对象的实例：

var dals = container.ResolveAll();foreach(IDal dal in dals){ dal.save();}
结果：

参考文档：

http://unity.codeplex.com http://www.cnblogs.com/dotview/archive/2011/08/08/2136762.html

Unity  注入方式

依赖注入方式

• 属性注入
• 构造函数注入
• 方法注入

1.属性注入

1.1 具体类型属性注入

public class MyObject
{
    private SomeOtherObject _dependentObject;

    [Dependency]
    public SomeOtherObject DependentObject
    {
        get { return _dependentObject; }
        set { _dependentObject = value; }
    }
} 

IUnityContainer uContainer = new UnityContainer();
MyObject myInstance = uContainer.Resolve();

// now access the property containing the dependency
SomeOtherObject depObj = myInstance.DependentObject;

1.2 接口和抽象类属性注入

public class MyObject
{
    private IMyInterface _interfaceObj;
    private MyBaseClass _baseObj;

    [Dependency]
    public IMyInterface InterfaceObject
    {
        get { return _interfaceObj; }
        set { _interfaceObj = value; }
    }

    [Dependency]
    public MyBaseClass BaseObject
    {
        get { return _baseObj; }
        set { _baseObj = value; }
    }
}

IUnityContainer uContainer = new UnityContainer()
   .RegisterType()
   .RegisterType();
MyObject myInstance = uContainer.Resolve();

// now access the properties containing the dependencies
IMyInterface depObjA = myInstance.InterfaceObject;
MyBaseClass depObjB = myInstance.BaseObject;

1.3 给属性注入命名

public class MyObject
{
    private IMyInterface _objA, _objB;

    [Dependency("MapTypeA")]
    public IMyInterface ObjectA
    {
        get { return _objA; }
        set { _objA = value; }
    }

    [Dependency("MapTypeB")]
    public IMyInterface ObjectB
    {
        get { return _objB; }
        set { _objB = value; }
    }
}

IUnityContainer uContainer = new UnityContainer()
   .RegisterType("MapTypeA")
   .RegisterType("MapTypeB");
MyObject myInstance = uContainer.Resolve();

// now access the properties containing the dependencies
IMyInterface depObjA = myInstance.ObjectA;
IMyInterface depObjB = myInstance.ObjectB;

2.构造函数注入

2.1 单构造函数

public class MyObject
{
    public MyObject(MyDependentClass myInstance)
    {
        // work with the dependent instance
        myInstance.SomeProperty = "SomeValue";
        // or assign it to a class-level variable
    }
}

IUnityContainer uContainer = new UnityContainer();
MyObject myInstance = uContainer.Resolve();

2.2 参数为接口或者基类注入

public class MyObject
{
    public MyObject(IMyInterface interfaceObj, MyBaseClass baseObj)
    {
        // work with the concrete dependent instances
        // or assign them to class-level variables
    }
} 

IUnityContainer uContainer = new UnityContainer()
   .RegisterType()
   .RegisterType();
MyObject myInstance = uContainer.Resolve();

2.3 多重构造函数通过属性指定注入构造函数

public class MyObject
{

    public MyObject(SomeOtherClass myObjA)
    {
        ....
    }

    [InjectionConstructor]
    public MyObject(MyDependentClass myObjB)
    {
        ....
    }
}

IUnityContainer uContainer = new UnityContainer();
MyObject myInstance = uContainer.Resolve();

3.方法注入

3.1 方法依赖于具体类

public class MyObject
{
    private SomeOtherObject dependentObject;

    [InjectionMethod]
    public void Initialize(SomeOtherObject dep)
    {
        // assign the dependent object to a class-level variable
        dependentObject = dep;
    }
}

IUnityContainer uContainer = new UnityContainer();
MyObject myInstance = uContainer.Resolve();

3.2 方法依赖于抽象类或接口

public class MyObject
{
    private IMyInterface depObjectA;
    private MyBaseClass depObjectB;

    [InjectionMethod]
    public void Initialize(IMyInterface interfaceObj, MyBaseClass baseObj)
    {
        depObjectA = interfaceObj;
        depObjectB = baseObj;
    }
}

IUnityContainer uContainer = new UnityContainer()
   .RegisterType()
   .RegisterType();
MyObject myInstance = uContainer.Resolve();

参考资料  http://www.cnblogs.com/benbenzlj/archive/2011/07/14/2106612.html