首页 > 代码库 > Unity 依赖注入

Unity 依赖注入

2024-10-08 15:42:02   230人阅读

这只是一些非常简单的示例，用于演示如何使用 Unity 进行依赖注入及 AOP。本文不会对 IoC，DI，AOP 等进行过多介绍。

依赖注入

使用 Unity 进行依赖注入，分为五个步骤：创建容器、注册对象或类型（Register）、注入、解析（Resolve）及 Dispose。

 

创建容器

1
IUnityContainer container = new UnityContainer();

 

Register

Register 用于向容器中注册对象或对象类型，只有在容器中正确注册的类型或对象才能在之后被解析出来。注册主要分为两种方式：类型注册 RegisterType 和实例注册 RegisterInstance。后者主要用于单例的情况。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
    //1. 最简单的情况
 
    //普通的类型
    container.RegisterType<IMyInterface, MyObj>();
    //泛型
    container.RegisterType<IList<string>, List<string>>();
    //用于 T 不确定的情况
    container.RegisterType(typeof(IList<>), typeof(List<>));
 
    //可用于单例模式
    container.RegisterInstance<IMyInterface>(new MyObj());
 
 
    //2. 有参构造函数,MyObj的构造函数需要一个字符串参数
    container.RegisterType<IMyInterface, MyObj>(new InjectionConstructor("hello world"));
     
    //3. 可选参数（如果 Unity 无法解析该类型，则传递 null）
    container.RegisterType<IMyInterface, MyObj>(
        new InjectionConstructor(new OptionalParameter(typeof(IMyParameter))));
     
    //4. 使用工厂方式
    container.RegisterType<IMyInterface,MyObj>(new InjectionFactory(type => new MyObj("Hello world"));
 
 
    //5. 生命周期管理（如果对同一个类型重复注册，则以最后注册的生命周期为准）
 
    //相当于单例，生命周期与容器一样
    container.RegisterType<IMyInterface, MyObj>(new ContainerControlledLifetimeManager());
 
    //每次从容器获取实例时，都重新创建
    container.RegisterType<IMyInterface, MyObj>(new TransientLifetimeManager());
 
    //每个线程第一次获取实例时，重新创建
    container.RegisterType<IMyInterface, MyObj>(new PerThreadLifetimeManager());
 
 
    //6. 结合 2 & 5
    container.RegisterType<IMyInterface, MyObj>(new ContainerControlledLifetimeManager(), new InjectionConstructor("hello world"));

 

上面演示的是在代码中进行注册，也可以在配置文件中进行注册。

 

使用配置文件进行注册的前提是只有真正会在后期进行改变的类型或对象提供配置文件，否则请使用代码进行注册，因为使用配置文件注册很难及时发现问题，更容易出错。
为了便于管理和维护，请在同一个文件中对所有本层次或整个项目要用到对象或类型进行注册，尽量不要在多个不同的文件中进行注册。

 

Inject 

注入主要有三种方式：构造函数注入，属性注入 和 方法注入。使用构造函数注入不会污染对象，使用属性注入，要求属性必须是 public 的，其次必须用 [Dependency] 进行标记。

 

Reslove

在需要使用的地方，通过 Reslove 从容器中获取实例。

1
2
3
4
5
    //直接获取
    container.Resolve<IMyInterface>();
 
    //覆盖掉传入的参数
    container.Resolve<IMyInterface>(new ParameterOverride("str", "hello guy"));

如果 MyObj 中的某一个属性也在 Container 中注册过的话，则在解析 MyObj 的时候，同时会解析该属性。

 

Dispose

对于那些生命周期与容器一样长的对象来说，当对容器进行 Dispose 的时候，会同时释放这些对象。

 

AOP

AOP 即面向方面编程，一般用于针对那些 crosscutting 的模块，主要为 日志，缓存，异常处理，验证，加密，性能监控等。Unity 提供了 Interception 扩展用于拦截对象消息从而进行 AOP 的编程，但它本身并不是一个真正意义上的 AOP 框架，因为它并不能直接往已经存在的对象中插入代码，也无法为构造函数插入代码。

 

首先，为 Unity 增加拦截器的扩展

1
2
IUnityContainer container = new UnityContainer();
container.AddNewExtension<Interception>();

这需要你先添加对 Microsoft.Practices.Unity.Interception 的引用

 

其次，确定方式

要使用 AOP，首先要告诉 Unity 通过哪种方式进入 AOP：InterfaceInterceptor、TransparentProxyInterceptor 及 VirtualMethodInterceptor。其中前两个是当 Unity 创建了对象实例后，再构建一个 proxy 对象包装这个实例，从而实现对实例进行拦截；而最后一个是通过构造一个派生类，然后再将这个派生类的实例返回给调用方，这种方式只适用于虚方法。

 

构造拦截器

实现 IInterceptionBehavior 接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
    class MyLogInterceptorBehavior : IInterceptionBehavior
    {
        public IEnumerable<Type> GetRequiredInterfaces()
        {
            return Type.EmptyTypes;
        }
 
        //核心部分
        public IMethodReturn Invoke(IMethodInvocation input, GetNextInterceptionBehaviorDelegate getNext)
        {
            //在方法真正执行前，先调用该行代码
            Console.WriteLine("Pre:method {0} is interceptor", input.MethodBase.Name);
 
            //调用下一个拦截器（如果没有拦截器，则直接调用目标方法）
            var result = getNext()(input, getNext);
 
            //方法执行后
            if (result.Exception != null)
            {
                //如果调用出错
            }
             
            Console.WriteLine("POST");
 
            return result;
        }
 
        //表示不管什么情况该拦截器都会执行
        public bool WillExecute
        {
            get { return true; }
        }       
    }

 

注册到容器中

如果有多个 Interceptor，则它们执行的顺序和它们注册时候的先后顺序有关，如下所示 MyCacheInterceptorBehavior 要后于 MyLogInterceptorBehavior 执行。

1
2
3
4
container.RegisterType<IMyInterface, MyObj>(
    new Interceptor<InterfaceInterceptor>(),
    new InterceptionBehavior<MyLogInterceptorBehavior>(),
    new InterceptionBehavior<MyCacheInterceptorBehavior>());

 

注，InterfaceInterceptor 一次只能对一个 interfcae 进行拦截，TransparentProxyInterceptor 可以对所有的接口方法进行拦截，也可以对派生自 MarshalByRefObject 类型中的方法进行拦截。

 

使用 Policy (策略) 来统一管理拦截器

当需要向容器中注册多个类型，而这些类型需要的拦截器都一样的情况下，如果每个都重复写，显然是不好的。这个时候就可以通过 Policy 来进行统一管理。

同样要先写一个拦截器，这次是实现 ICallHandler 接口。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
    //实现 ICallHandler，和 IInterceptionBehavior 很相似
    class MyLogInterceptorHandler : ICallHandler
    {
        public IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext)
        {
            Console.WriteLine("Pre MyLog");
 
            IMethodReturn result = getNext()(input, getNext);
            if (result.Exception != null)
            {
                //如果调用出错
            }
 
            Console.WriteLine("Post MyLog");
 
            return result;
        }
 
        public int Order
        {
            get;
            set;
        }
    }

 

然后进行注册。

1
2
3
4
5
6
7
8
9
container.RegisterType<IMyInterface, MyObj>(
new Interceptor<InterfaceInterceptor>(),
new InterceptionBehavior<PolicyInjectionBehavior>());
 
//配置 Policy
container.Configure<Interception>()
    .AddPolicy("hello") //用于方便日后维护时能够清楚的知道这个 policy 的作用
    .AddMatchingRule(new NamespaceMatchingRule("ConsoleApplication1"))
    .AddCallHandler<MyLogInterceptorHandler>(new ContainerControlledLifetimeManager());

AddMatchingRule 表示当前 Policy 适用于哪些类型，如何去匹配这些类型。上例中，使用的是 NamespaceMatchingRule 表示只要容器中注册的类型是属于该名称空间的，则为此类型应用这个 Policy。可以添加多个 MatchingRule，它们之间是 “与” 的关系，也就是说要同时满足所有的 MatchingRule 才能应用该 Policy。

AddCallHandler 则用于表示一个拦截器。

 

使用 Attribute 来进行拦截

如果觉得通过 MatchingRule 的方式不够直观，可以使用 Attribute 的方式。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
    class MyLogInterceptorAttribute:HandlerAttribute
    {
        public override ICallHandler CreateHandler(IUnityContainer container)
        {
            return new MyLogInterceptorHandler { Order = Order };
        }
    }
     
     class MyLogInterceptorAttribute2:HandlerAttribute
    {
        public override ICallHandler CreateHandler(IUnityContainer container)
        {
            return new MyLogInterceptorHandler2 { Order = Order };
        }
    }

定义一个新的 Attribute 很简单，而关键代码就是重写了 CreateHandler 方法，该方法会返回在上一步中创建的 CallHandler。

在需要使用的类上，直接添加此 Attribute 即可。

1
2
3
4
5
[MyLogInterceptor]
[MyLogInterceptor2]
public class MyObj : IMyInterface
{
}

注册的代码和 Policy 一样，只是省去了配置 Matching Rule 的步骤：

1
2
3
container.RegisterType<IMyInterface, MyObj>(
new Interceptor<InterfaceInterceptor>(),
new InterceptionBehavior<PolicyInjectionBehavior>());

 

拦截顺序

1、如果不显示提供 Order 属性，那添加 Attribute 的上下顺序决定了拦截的先后，从上到下依次拦截。

上面的代码在运行后，调用 MyObj 中接口的方法，首先会被 MyLogInterceptor 拦截，然后会被 MyLogInterceptor2 拦截。

2、Order 可为负数，如果显示提供了 Order （Order = 0 除外），那拦截的顺序即是从小到大的顺序。如下，

1
2
3
4
5
[MyLogInterceptor(Order = -2)]
[MyLogInterceptor2(Order = -10)]
public class MyObj : IMyInterface
{
}

上面在调用方法后，先被 MyLogInterceptor2 拦截，其次才是被 MyLogInterceptor 拦截。

3、未显示提供 Order 属性的永远排在 提供了 Order 属性的拦截器后。

Order = 0，与没有提供 Order 的效果是等效的。

Unity 依赖注入


联系
我们