AutoFac Ioc依赖注入容器

最新推荐文章于 2022-04-15 16:36:39 发布
最新推荐文章于 2022-04-15 16:36:39 发布
阅读量241 收藏
点赞数
文章标签： 测试
原文链接：http://www.cnblogs.com/licin/p/6560426.html
版权

本文原著：牛毅  原文路径 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  }

 

 

 

 

转载于:https://www.cnblogs.com/licin/p/6560426.html

weixin_33901926
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
autofac+mvc5+三层-ioc
11-14
一个关于mvc5使用autofac实现ioc的demo。详细说明：https://www.cnblogs.com/1439107348s/p/9957307.html
Ioc容器Autofac系列（1）-- 初窥
weixin_30294021的博客
11-21 162
前言 第一次接触Autofac是因为CMS系统--Orchard，后来在一个开源爬虫系统--NCrawler中也碰到过，随着深入了解，我越发觉得Ioc容器是Web开发中必不可少的利器。那么，Ioc容器是用来做什么的？用了有什么好处？我相信如果不明白这两点就很难敞开心扉接受Ioc容器。 传统解耦设计的弊端 为方便描述，举个日志的栗子。我简化实现，一个Log类，一个SaveLog方法。如果其他类...
.NET领域最为流行的IOC框架之一Autofac
weixin_33857679的博客
04-12 705
一、前言 Autofac是.NET领域最为流行的IOC框架之一，微软的Orchad开源程序使用的就是Autofac，Nopcommerce开源程序也是用的Autofac。 Orchad和Nopcommerce在用Autofac的时候进行封装，看过源码的都知道Autafac使用简单，功能强大。 建议下载Orchad和Nopcommerce学习下源码：附上下载地址 http://www.orc...
Ioc容器Autofac介绍
WebFocus
08-11 183
Autofac是轻量级的开源Ioc容器，在这里可以下载http://code.google.com/p/autofac/。如果你用过其他的Ioc容器，那么学习Autofac使用也会比较容易，下面将通过一些例子来讲解其用法。 先看一个例子： 首先新建一个工程，添加Autofac引用。 准备代码，和之前的一样 interface IDal { v...
使用Autofac做ioc
小猪快跑
12-12 361
一.目前流行的ioc框架： Unity：微软patterns&amp;amp;amp;amp;practicest团队开发的IOC依赖注入框架，支持AOP横切关注点。（下篇文章会写） MEF（Managed Extensibility Framework）：是一个用来扩展.NET应用程序的框架，可开发插件系统。MEF（Managed Extensibility Framework）：是一个用来扩展.NET应用程序的框架...
NopCommerce架构分析(一)Autofac依赖注入类生成容器
10-22
本文介绍了NopCommerce中IOC框架Autofac的使用，Autofac是一款IOC框架，比较于其他的IOC框架，如Spring.NET，Unity，Castle等等所包含的，它很轻量级性能上非常高。
.NET Autofac依赖注入
12-15
依赖注入又称之为控制反转（Inversion of Control，英文缩写为IoC）是一个重要的面向对象编程的法则来削减计算机程序的耦合问题，也是轻量级的Spring框架的核心。 控制反转一般分为两种类型，依赖注入（Dependency ...
Typefac:基于Autofac的TypeScript IoC容器
05-21
Typefac 基于Autofac的TypeScript IoC容器
MVC4使用Autofac实现依赖注入Demo
11-07
MVC4使用Autofac实现依赖注入Demo,基于MVC4.0的
Autofac依赖注入
04-08
使用Autofac依赖项注入容器可以简化面向对象应用程序的配置。
IOC和Autofac简单说明
gfchjfdvv的博客
04-15 694
一、IOC控制反转 1、IOC的概念 IOC-Invertion of Control,即控制反转，是一种程序设计思想。 依赖（Dependency）：就是有联系，表示一个类依赖于另一个类。 依赖倒置原则（DIP）：设计模式六大原则之一，是一种软件架构设计原则。 控制反转（IOC）：一种软件设计原则，上层对下层的依赖（即底层模块的获得）交给第三方。 依赖注入（DI）：实现IOC的一种方式、手段。 IOC容器：依赖注入的框架，用来映射依赖，管理对象创建和生存周期。 2、IOC的原理 反..
autofac IOC
weixin_33949359的博客
01-11 126
http://www.cnblogs.com/liupeng/p/4806184.html   srvanyui  自建服务
AutofacContainer
weixin_30617561的博客
11-15 173
/// <summary> /// Autofac容器 /// </summary> public class AutofacContainer { public static IContainer Container { get; private set; } public sta...
Ioc容器Autofac
Vincent_yuan1991的博客
04-19 429
Ioc容器Autofac系列（1）– 初窥前言 第一次接触Autofac是因为CMS系统–Orchard，后来在一个开源爬虫系统–NCrawler中也碰到过，随着深入了解，我越发觉得Ioc容器是Web开发中必不可少的利器。那么，Ioc容器是用来做什么的？用了有什么好处？我相信如果不明白这两点就很难敞开心扉接受Ioc容器。传统解耦设计的弊端 为方便描述，举个日志的栗子。我简化实现，一个Log类，一
.Net Core IOC依赖注入和Autofac(二)
飞翔的学习笔记
01-04 852
上次记录了如何在.Net Core下实现IOC,和使用第三方的Autofac来替换自带的IOC框架。 继续来聊下Autofac注册程序集的方法，上次就对单个接口实现了注册，这次要讲如何对程序集进行注册 Autofac注册之前已经讲了在Startup文件中对ConfigureServices方法改造返回IServiceProvider ，具体如IServiceProvider Configure...
Autofac IOC框架
weixin_30650039的博客
02-28 133
ASP.NET Core自带了一个轻量级的IOC容器 但是只提供了最基本的AddXXX方法来绑定实例关系 需要一个一个添加 可以使用其他IOC容器来替换内置的 ABP自带Castle容器 1.安装Nuget包Autofac 和Autofac.Extensions.DependencyInjection 2.使用Autofac替换自带的IO...
IOC容器Autofac使用
weixin_30333885的博客
06-04 140
今天我沉浸在IOC的设计模式追求中，听了很多课，也看了很多例子，这个是我的一个测试项目 为了测试代码，我首先准备了两个类一个Car和接口ICar，这两个类和我们平时项目中的DAL与IDAL相似，现在我们开始！ 1.首先添加一个类InitAutofac在我们的程序中 对了，这个是我的程序集 这个有点小问题，因为我ICar和Car放在了SourceClass文件中但是问题不大 2....
C#中IOC容器-Autofac的使用
混迹自留地
06-07 1718
什么是Ioc 把对象的统一创建交给第三方容器来创建 Autofac容器初识 auto 是一款有优秀的IOC容器：那么如何使用？第三方容器 Nuget引入程序包autofac 创建containerBuilder 注册首先和实现的关系 Build一下，得到ConTainer容器 用去获取服务实例 使用服务 代码实现 //构造函数注入 //ContainerBuilder containerBuilder = new ContainerBuil
.Net Framework MVC IOC依赖注入
最新发布
07-25
1. 配置依赖注入容器：您可以使用第三方的依赖注入容器，如 Autofac、Unity、Ninject 等，或者使用 .NET Framework 自带的简单容器（如 `UnityContainer`）。 2. 注册依赖项：在配置阶段，您需要将控制器、服务、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值