依赖注入容器Unity介绍

最新推荐文章于 2024-08-20 15:00:00 发布

longren629

最新推荐文章于 2024-08-20 15:00:00 发布

阅读量354

点赞数

分类专栏： C# 文章标签： sqlserver class properties containers access variables

C# 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

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

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

Unity的实现如下：

1、创建容器

2、注册映射

a) 代码方式注册映射：

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) 通过配置方式注册映射：

配置方式完整代码：

3、获取对象实例

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

结果：

参考文档：

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<MyObject>();

// 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<IMyInterface, FirstObject>()
   .RegisterType<MyBaseClass, SecondObject>();
MyObject myInstance = uContainer.Resolve<MyObject>();

// 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<IMyInterface, FirstObject>("MapTypeA")
   .RegisterType<IMyInterface, SecondObject>("MapTypeB");
MyObject myInstance = uContainer.Resolve<MyObject>();

// 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<MyObject>();

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<IMyInterface, FirstObject>()
   .RegisterType<MyBaseClass, SecondObject>();
MyObject myInstance = uContainer.Resolve<MyObject>();

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

public class MyObject
{

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

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

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

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<MyObject>();

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<IMyInterface, FirstObject>()
   .RegisterType<MyBaseClass, SecondObject>();
MyObject myInstance = uContainer.Resolve<MyObject>();

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