本文原著：牛毅 原文路径 http://niuyi.github.io/blog/2012/04/06/autofac-by-unit-test/
理解IOC容器请看下图：
没有使用IOC容器的情况下:
使用IOC容器的情况下：
去掉IOC容器的情况后：
IOC容器又像一个插座，将电输送到需要的每一处。需要充电的话，就连接，不需要就不连接，节省资源，不用时时刻刻连上电源了。省电的，哈哈。
使用IOC容器的好处：
1) 可维护性比较好
2) 便于单元测试，调试程序和诊断故障
2) 可复用性好
实现组件之间的解耦，提高程序的灵活性和可维护性
AutoFac使用方法总结:Part I
APR 6TH, 2012 | COMMENTS
AutoFac是.net平台下的IOC容器产品，它可以管理类之间的复杂的依赖关系。在使用方面主要是register和resolve两类操作。 这篇文章用单元测试的形式列举了AutoFac的常用使用方法：
注册部分
使用RegisterType进行注册
1
2
3
4
5
6
7
8
9
10
|
[Fact]
public void can_resolve_myclass()
{
var builder = new ContainerBuilder();
builder.RegisterType<MyClass>();
IContainer container = builder.Build();
var myClass = container.Resolve<MyClass>();
Assert.NotNull(myClass);
}
|
注册为接口
1
2
3
4
5
6
7
8
9
10
|
[Fact]
public void register_as_interface()
{
var builder = new ContainerBuilder();
builder.Register(c => new MyClass()).As<MyInterface>();
IContainer container = builder.Build();
Assert.NotNull(container.Resolve<MyInterface>());
Assert.Throws(typeof (ComponentNotRegisteredException), () => container.Resolve<MyClass>());
}
|
使用lambda表达式进行注册
1
2
3
4
5
6
7
8
9
10
|
[Fact]
public void can_register_with_lambda()
{
var builder = new ContainerBuilder();
builder.Register(c => new MyClass());
IContainer container = builder.Build();
var myClass = container.Resolve<MyClass>();
Assert.NotNull(myClass);
}
|
带构造参数的注册
1
2
3
4
5
6
7
8
9
|
[Fact]
public void register_with_parameter()
{
var builder = new ContainerBuilder();
builder.Register(c => new MyParameter());
builder.Register(c => new MyClass(c.Resolve<MyParameter>()));
IContainer container = builder.Build();
Assert.NotNull(container.Resolve<MyClass>());
}
|
带属性赋值的注册
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
[Fact]
public void register_with_property()
{
var builder = new ContainerBuilder();
builder.Register(c => new MyProperty());
builder.Register(
c => new MyClass()
{
Property = c.Resolve<MyProperty>()
});
IContainer container = builder.Build();
var myClass = container.Resolve<MyClass>();
Assert.NotNull(myClass);
Assert.NotNull(myClass.Property);
}
|
Autofac分离了类的创建和使用，这样可以根据输入参数（NamedParameter）动态的选择实现类。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
[Fact]
public void select_an_implementer_based_on_parameter_value()
{
var builder = new ContainerBuilder();
builder.Register<IRepository>((c, p) =>
{
var type = p.Named<string>("type");
if (type == "test")
{
return new TestRepository();
}
else
{
return new DbRepository();
}
}).As<IRepository>();
IContainer container = builder.Build();
var repository = container.Resolve<IRepository>(new NamedParameter("type", "test"));
Assert.Equal(typeof(TestRepository),repository.GetType());
}
|
AufoFac也可以用一个实例来注册，比如用在单例模式情况下：
1
2
3
4
5
6
7
8
9
10
|
[Fact]
public void register_with_instance()
{
var builder = new ContainerBuilder();
builder.RegisterInstance(MyInstance.Instance).ExternallyOwned();
IContainer container = builder.Build();
var myInstance1 = container.Resolve<MyInstance>();
var myInstance2 = container.Resolve<MyInstance>();
Assert.Equal(myInstance1,myInstance2);
}
|
注册open generic类型
1
2
3
4
5
6
7
8
9
10
11
|
[Fact]
public void register_open_generic()
{
var builder = new ContainerBuilder();
builder.RegisterGeneric(typeof (MyList<>));
IContainer container = builder.Build();
var myIntList = container.Resolve<MyList<int>>();
Assert.NotNull(myIntList);
var myStringList = container.Resolve<MyList<string>>();
Assert.NotNull(myStringList);
}
|
对于同一个接口，后面注册的实现会覆盖之前的实现
1
2
3
4
5
6
7
8
9
10
11
|
[Fact]
public void register_order()
{
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterType<DbRepository>().As<IRepository>();
containerBuilder.RegisterType<TestRepository>().As<IRepository>();
IContainer container = containerBuilder.Build();
var repository = container.Resolve<IRepository>();
Assert.Equal(typeof(TestRepository), repository.GetType());
}
|
如果不想覆盖的话，可以用PreserveExistingDefaults，这样会保留原来注册的实现。
1
2
3
4
5
6
7
8
9
10
11
|
[Fact]
public void register_order_defaults()
{
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterType<DbRepository>().As<IRepository>();
containerBuilder.RegisterType<TestRepository>().As<IRepository>().PreserveExistingDefaults();
IContainer container = containerBuilder.Build();
var repository = container.Resolve<IRepository>();
Assert.Equal(typeof (DbRepository), repository.GetType());
}
|
可以用Name来区分不同的实现，代替As方法
1
2
3
4
5
6
7
8
9
10
11
12
13
|
[Fact]
public void register_with_name()
{
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterType<DbRepository>().Named<IRepository>("DB");
containerBuilder.RegisterType<TestRepository>().Named<IRepository>("Test");
IContainer container = containerBuilder.Build();
var dbRepository = container.ResolveNamed<IRepository>("DB");
var testRepository = container.ResolveNamed<IRepository>("Test");
Assert.Equal(typeof(DbRepository), dbRepository.GetType());
Assert.Equal(typeof(TestRepository), testRepository.GetType());
}
|
如果一个类有多个构造函数的话，可以在注册时候选择不同的构造函数
1
2
3
4
5
6
7
8
9
10
|
[Fact]
public void choose_constructors()
{
var builder = new ContainerBuilder();
builder.RegisterType<MyParameter>();
builder.RegisterType<MyClass>().UsingConstructor(typeof (MyParameter));
IContainer container = builder.Build();
var myClass = container.Resolve<MyClass>();
Assert.NotNull(myClass);
}
|
AutoFac可以注册一个Assemble下所有的类，当然，也可以根据类型进行筛选
1
2
3
4
5
6
7
8
9
10
11
12
|
[Fact]
public void register_assembly()
{
var builder = new ContainerBuilder();
builder.RegisterAssemblyTypes(Assembly.GetExecutingAssembly()).
Where(t => t.Name.EndsWith("Repository")).
AsImplementedInterfaces();
IContainer container = builder.Build();
var repository = container.Resolve<IRepository>();
Assert.NotNull(repository);
}
|
AutoFac使用方法总结:Part II
APR 6TH, 2012 | COMMENTS
事件
AutoFac支持三种事件：OnActivating，OnActivated，OnRelease。OnActivating在注册组件使用之前会被调用，此时可以替换实现类或者进行一些其他的初始化工作，OnActivated在实例化之后会被调用，OnRelease在组件释放之后会被调用。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public class MyEvent : IDisposable
{
public MyEvent(string input)
{
Console.WriteLine(input);
}
public MyEvent()
{
Console.WriteLine("Init");
}
public void Dispose()
{
Console.WriteLine("Dispose");
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
public void test_event()
{
var builder = new ContainerBuilder();
builder.RegisterType<MyEvent>().
OnActivating(e => e.ReplaceInstance(new MyEvent("input"))).
OnActivated(e => Console.WriteLine("OnActivated")).
OnRelease(e => Console.WriteLine("OnRelease"));
using (IContainer container = builder.Build())
{
using (var myEvent = container.Resolve<MyEvent>())
{
}
}
}
|
此时的输出为：
1
2
3
4
5
|
Init
input
OnActivated
Dispose
OnRelease
|
利用事件可以在构造对象之后调用对象的方法：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
[Fact]
public void call_method_when_init()
{
var builder = new ContainerBuilder();
builder.RegisterType<MyClassWithMethod>().OnActivating(e => e.Instance.Add(5));
IContainer container = builder.Build();
Assert.Equal(5, container.Resolve<MyClassWithMethod>().Index);
}
public class MyClassWithMethod
{
public int Index { get; set; }
public void Add(int value)
{
Index = Index + value;
}
}
|
循环依赖
循环依赖是个比较头疼的问题，在AutoFac中很多循环依赖的场景不被支持：
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
|
public class ClassA
{
private readonly ClassB b;
public ClassA(ClassB b)
{
this.b = b;
}
}
public class ClassB
{
public ClassA A { get; set; }
}
[Fact]
public void circular_dependencies_exception()
{
var builder = new ContainerBuilder();
builder.Register(c => new ClassB(){A = c.Resolve<ClassA>()});
builder.Register(c => new ClassA(c.Resolve<ClassB>()));
IContainer container = builder.Build();
Assert.Throws(typeof(DependencyResolutionException), ()=>container.Resolve<ClassA>());
}
|
可以部分的解决这种循环依赖的问题，前提是ClassA和ClassB的生命周期不能都是InstancePerDependency
1
2
3
4
5
6
7
8
9
10
11
12
|
[Fact]
public void circular_dependencies_ok()
{
var builder = new ContainerBuilder();
builder.RegisterType<ClassB>().
PropertiesAutowired(PropertyWiringFlags.AllowCircularDependencies).SingleInstance();
builder.Register(c => new ClassA(c.Resolve<ClassB>()));
IContainer container = builder.Build();
Assert.NotNull(container.Resolve<ClassA>());
Assert.NotNull(container.Resolve<ClassB>());
Assert.NotNull(container.Resolve<ClassB>().A);
}
|
AutoFac使用方法总结:Part III
APR 6TH, 2012 | COMMENTS
生命周期
AutoFac中的生命周期概念非常重要，AutoFac也提供了强大的生命周期管理的能力。
AutoFac定义了三种生命周期：
Per Dependency
Single Instance
Per Lifetime Scope
Per Dependency为默认的生命周期，也被称为’transient’或’factory’，其实就是每次请求都创建一个新的对象
1
2
3
4
5
6
7
8
9
10
|
[Fact]
public void per_dependency()
{
var builder = new ContainerBuilder();
builder.RegisterType<MyClass>().InstancePerDependency();
IContainer container = builder.Build();
var myClass1 = container.Resolve<MyClass>();
var myClass2 = container.Resolve<MyClass>();
Assert.NotEqual(myClass1,myClass2);
}
|
Single Instance也很好理解，就是每次都用同一个对象
1
2
3
4
5
6
7
8
9
10
11
12
|
[Fact]
public void single_instance()
{
var builder = new ContainerBuilder();
builder.RegisterType<MyClass>().SingleInstance();
IContainer container = builder.Build();
var myClass1 = container.Resolve<MyClass>();
var myClass2 = container.Resolve<MyClass>();
Assert.Equal(myClass1,myClass2);
}
|
Per Lifetime Scope，同一个Lifetime生成的对象是同一个实例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
[Fact]
public void per_lifetime_scope()
{
var builder = new ContainerBuilder();
builder.RegisterType<MyClass>().InstancePerLifetimeScope();
IContainer container = builder.Build();
var myClass1 = container.Resolve<MyClass>();
var myClass2 = container.Resolve<MyClass>();
ILifetimeScope inner = container.BeginLifetimeScope();
var myClass3 = inner.Resolve<MyClass>();
var myClass4 = inner.Resolve<MyClass>();
Assert.Equal(myClass1,myClass2);
Assert.NotEqual(myClass2,myClass3);
Assert.Equal(myClass3,myClass4);
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
[Fact]
public void life_time_and_dispose()
{
var builder = new ContainerBuilder();
builder.RegisterType<Disposable>();
using (IContainer container = builder.Build())
{
var outInstance = container.Resolve<Disposable>(new NamedParameter("name", "out"));
using(var inner = container.BeginLifetimeScope())
{
var inInstance = container.Resolve<Disposable>(new NamedParameter("name", "in"));
}//inInstance dispose here
}//out dispose here
}
|
- IoC 依赖注入容器 Unity
原文:IoC 依赖注入容器 Unity IoC 是什么? 在软件工程领域,“控制反转(Inversion of Control,缩写为IoC)”是一种编程技术,表述在面向对象编程中,可描述为在编译时静 ...
- Asp.net core自定义依赖注入容器，替换自带容器
依赖注入 在asp.net core程序中,众所周知,依赖注入基本上贯穿了整个项目,以通用的结构来讲解,控制器层(Controller层)依赖业务层(Service层),业务层依赖于仓储层(Repos ...
- Asp.Net Core 进阶（三）—— IServiceCollection依赖注入容器和使用Autofac替换它
Asp.Net Core 提供了默认的依赖注入容器 IServiceCollection,它是一个轻量级的依赖注入容器,所以功能不多,只是提供了基础的一些功能,要实现AOP就有点麻烦,因此在实际工作当 ...
- Autofac依赖注入容器
依赖注入容器-- Autofac https://github.com/danielpalme/IocPerformance Unity 更新频率高,微软的项目Grace 综合性能更高 目录: 一.简 ...
- 依赖注入容器Autofac的详解
Autofac和其他容器的不同之处是它和C#语言的结合非常紧密,在使用过程中对你的应用的侵入性几乎为零,更容易与第三方的组件集成,并且开源,Autofac的主要特性如下: 1,灵活的组件实例化:Aut ...
- ASP.NET MVC IOC依赖注入之Autofac系列（二）- WebForm当中应用
上一章主要介绍了Autofac在MVC当中的具体应用,本章将继续简单的介绍下Autofac在普通的WebForm当中的使用. PS:目前本人还不知道WebForm页面的构造函数要如何注入,以下在Web ...
- ASP.NET MVC IOC依赖注入之Autofac系列（一）- MVC当中应用
话不多说,直入主题看我们的解决方案结构: 分别对上面的工程进行简单的说明: 1.TianYa.DotNetShare.Model:为demo的实体层 2.TianYa.DotNetShare.Repo ...
- NopCommerce使用Autofac实现依赖注入
NopCommerce的依赖注入是用的AutoFac组件,这个组件在nuget可以获取,而IOC反转控制常见的实现手段之一就是DI依赖注入,而依赖注入的方式通常有:接口注入.Setter注入和构造函数 ...
- NET Core源代码通过Autofac实现依赖注入
查看.NET Core源代码通过Autofac实现依赖注入到Controller属性 阅读目录 一.前言 二.使用Autofac 三.最后 回到目录 一.前言 在之前的文章[ASP.NET Cor ...
随机推荐
- maven本地仓库中存在jar包，但编译不成功，显示jar包不存在
介绍一下背景,项目要迁移进坑人的离线的内网开发,将在同事那编译通过的代码和maven仓库拷进内网,打算编译通过之后再上传私服,结果配好maven之后,本地库中的部分jar包显示没有引入,如下面的波浪线 ...
- prestashop nginx rewrite rule
server { listen *:; server_name www.mydomain.com *.mydomain.com; root /var/www/www.mydomain.com/web; ...
- memcached配置 启动
memcached:http://memcached.org/ libevent:http://libevent.org/ #下载包 cd /opt wget https://github.com/d ...
- 每帧创建一个item
-- 加载列表测试 function UIBagController:onLoadTest() self.goodsprop = DB.getTable("goodsprop"); ...
- python和shell变量互相传递
python -> shell: 1.环境变量 复制代码 代码如下: import os var=123或var='123'os.environ['var']=str(var) #envir ...
- python工具 - 批量文件重命名
日常工作中经常会遇到这样的情况,需要将某个文件夹下的文件按着一定的规则进行重命名,当文件数量及其庞大的时候手工一个一个的去修需要耗费大量的时间,以下python工具可以协助批量修改文件名. 场景:某文 ...
- 《CLR via C#》读书笔记 之 线程基础
第二十五章 线程基础 2014-06-28 25.1 Windows为什么要支持线程 25.2 线程开销 25.3 停止疯狂 25.6 CLR线程和Windows线程 25.7 使用专用线程执行异步的 ...
- JS中的Map和Set实现映射对象
使用iterable内置的forEach方法 var a = ['A', 'B', 'C']; a.forEach(function (element, index, array) { // elem ...
- MXNET：多层感知机
从零开始 前面了解了多层感知机的原理,我们来实现一个多层感知机. # -*- coding: utf-8 -*- from mxnet import init from mxnet import nd ...
- 【Spring源码分析】Bean加载流程概览(转)
转载自:https://www.cnblogs.com/xrq730/p/6285358.html 代码入口 之前写文章都会啰啰嗦嗦一大堆再开始,进入[Spring源码分析]这个板块就直接切入正题了. ...
