Autofac注册详解

注册概念:
我们通过创建 ContainerBuilder 来注册组件并且告诉容器哪些组件暴露了哪些服务.组件可以通过反射创建; 通过提供现成的实例创建; 或者通过 lambda 表达式来创建.

ContainerBuilder 包含一组 Register() 方法来帮你实现以上操作.每个组件暴露一个或多个服务 ,他们使用 ContainerBuilder 上的 As() 方法连接起来.

 1 //注册类
 2 var builder = new ContainerBuilder();
 3 
 4 builder.RegisterType<ConsoleLogger>().As<ILogger>();
 5 
 6 //注册实例
 7 
 8 var output = new StringWriter();
 9 
10 builder.RegisterInstance(output).As<TextWriter>();
11 
12 //注册lambda表达式
13 
14 builder.Register(c => new ConfigReader("mysection")).As<IConfigReader>();
15 
16 
17 var container = builder.Build();
18 
19 using(var scope = container.BeginLifetimeScope())
20 {
21   var reader = scope.Resolve<IConfigReader>();
22 }

通过类型注册

builder.RegisterType<ConsoleLogger>();

builder.RegisterType(typeof(ConfigReader));

当使用基于反射的组件时, Autofac 自动为你的类从容器中寻找匹配拥有最多参数的构造方法.

指定构造函数
你可以使用 UsingConstructor 方法和构造方法中一系列代表参数类型的类型来手动指定一个构造函数

builder.RegisterType<MyComponent>().UsingConstructor(typeof(ILogger), typeof(IConfigReader));

通过实例注册：

有时候你也许会希望提前生成一个对象的实例并将它加入容器以供注册组件时使用：

var output = new StringWriter();
builder.RegisterInstance(output).As<TextWriter>();

当你这样做时你需要考虑一些事情, Autofac 自动处理已注册组件的释放 ,你也许想要自己来控制生命周期而不是让Autofac来帮你调用 Dispose 释放你的对象. 在这种情况下, 你需要通过 ExternallyOwned 方法来注册实例:

var output = new StringWriter();
builder.RegisterInstance(output)
.As<TextWriter>().ExternallyOwned();

通过Lambda表达式注册：
通常情况下使用类型注册组件. 但是,当组件创建不再是简单的调用构造方法时，就需要使用Lambda表达式
Autofac接收一个委托或者lambda表达式, 用作组件创建者:

builder.Register(c => new A(c.Resolve<B>()));

表达式提供的参数 c 是组件上下文 (一个 IComponentContext 对象) , 组件在其中被创建. 你可以使用这个参数来从容器中解析出其他值来帮助创建你的组件. 使用这个参数而不是一个闭包来访问容器非常重要这样可以保证对象精确的释放并且可以很好的支持嵌套容器.

使用该上下文参数可以满足其他依赖的成功引入 - 例如, A 需要一个构造方法参数 B ,而 B 可能还有其他的依赖关系.

复杂参数

builder.Register(c => new UserSession(DateTime.Now.AddMinutes(25)));

参数注入，你可以使用表达式和属性初始化来填充参数:

builder.Register(c => new A(){ MyB = c.ResolveOptional<B>() });

ResolveOptional 方法会尝试解析, 但如果服务没有注册, 不会抛出错误. (如果服务成功注册但是无法成功解析, 你依然会得到一个错误.) 这是解析服务的一种方式.

在大多数情况下不推荐使用参数注入. 使用其他的例如空对象模式, 重载构造方法或参数默认值这些方式, 用构造方法注入可以创建出可选依赖的更清爽, "不可变" 组件.

通过参数值选择具体的实现
创建分离组件的一大好处是具体的类型可以是多种多样的. 指定具体的类型通常可以在运行时完成, 而不仅仅是配置时期:
builder.Register<CreditCard>(
(c, p) =>
{
var accountId = p.Named<string>("accountId");
if (accountId.StartsWith("9"))
{
return new GoldCard(accountId);
}
else
{
return new StandardCard(accountId);
}
});

示例中, CreditCard 通过两种类实现, GoldCard 和 StandardCard - 哪个类会被实例化取决于运行时期间提供的account ID.
示例中创建方法的参数通过第二个可选的参数 p 传入.
解析时可以这样:

var card = container.Resolve<CreditCard>(new NamedParameter("accountId", "12345"));

如果声明一个创建 CreditCard 实例的委托和一个委托工厂 , 语法可以变得更加干净, 类型安全.

注册泛型组件
Autofac支持开放泛型. 使用 RegisterGeneric() 方法:

builder.RegisterGeneric(typeof(NHibernateRepository<>))
.As(typeof(IRepository<>))
.InstancePerLifetimeScope();

当容器请求一个匹配的服务类型时, Autofac将会找到对应的封闭类型的具体实现:

// return an NHibernateRepository<Task>
var tasks = container.Resolve<IRepository<Task>>();

暴露服务：
注册组件时, 我们得告诉Autofac, 组件暴露了哪些服务 . 默认地, 类型注册时大部分情况下暴露它们自身:

builder.RegisterType<CallLogger>();

你可以让一个组件暴露任意数量的服务:

builder.RegisterType<CallLogger>()
.As<ILogger>()
.As<ICallInterceptor>();

暴露服务后, 你就可以解析基于该服务的组件了. 但请注意, 一旦你将组件暴露为一个特定的服务, 默认的服务 (组件类型) 将被覆盖:

scope.Resolve<ILogger>();
scope.Resolve<ICallInterceptor>();

// This WON'T WORK anymore because we specified
// service overrides on the component:
scope.Resolve<CallLogger>();

如果你既想组件暴露一系列特定的服务, 又想让它暴露默认的服务, 可以使用 AsSelf 方法:

builder.RegisterType<CallLogger>()
.AsSelf()
.As<ILogger>()
.As<ICallInterceptor>();

这样所有的解析就都能成功了:

scope.Resolve<ILogger>();
scope.Resolve<ICallInterceptor>();
scope.Resolve<CallLogger>();

默认注册，如果不止一个组件暴露了相同的服务, Autofac将使用最后注册的组件作为服务的提供方:

builder.RegisterType<ConsoleLogger>().As<ILogger>();
builder.RegisterType<FileLogger>().As<ILogger>();

上例中, FileLogger 将会作为 ILogger 默认的服务提供方因为它是最后被注册的.
想要覆盖这种行为, 使用 PreserveExistingDefaults() 方法修改:
builder.RegisterType<ConsoleLogger>().As<ILogger>();
builder.RegisterType<FileLogger>().As<ILogger>().PreserveExistingDefaults();

上例中, ConsoleLogger 将会作为 ILogger 默认的服务提供方因为最后注册的 FileLogger 使用了 PreserveExistingDefaults().
有条件的注册
注解
有条件的注册自Autofac 4.4.0 引入
大多数情况下, 像上面那样覆盖默认的注册其实已经足够让我们在运行时成功地解析正确的组件了. 我们可以使用 PreserveExistingDefaults() 保证组件以正确的顺序被注册; 对于复杂的条件和行为我们也可以利用 lambda表达式/委托注册处理的很不错了.
但依然有些场景应该是你不想碰到的:
你不想在程序中有些功能在正常运作的情况下某个组件还会出现. 例如, 如果你解析了 IEnumerable<T> 的服务(一堆服务), 所有实现了这些服务的已注册组件都将被返回, 不管你是否使用了 PreserveExistingDefaults(). 大多数情况下这样也行, 但在某些极端情况下你不希望如此.
你只想要在其他一些组件未被注册的情况下才注册组件; 或者只想在其他一些组件已被注册的情况下. 你不会从容器中解析出你不想要的东西, 并且你也不用修改已经创建的容器. 能够基于其他的注册情况来进行有条件的组件注册非常好用.
这边有两种好用的注册扩展方法:
OnlyIf() - 提供一个表达式, 使用一个 IComponentRegistry 来决定注册是否发生.
IfNotRegistered() - 有其他服务已被注册的情况下阻止注册发生的快捷方法.
这些方法在 ContainerBuilder.Build() 时执行并且以实际组件注册的顺序执行. 下面是一些展示它们如何工作的示例:
var builder = new ContainerBuilder();

builder.RegisterType<ServiceA>()
.As<IService>();
builder.RegisterType<ServiceB>()
.As<IService>()
.IfNotRegistered(typeof(IService));

builder.RegisterType<HandlerA>()
.AsSelf()
.As<IHandler>()
.IfNotRegistered(typeof(HandlerB));
builder.RegisterType<HandlerB>()
.AsSelf()
.As<IHandler>();
builder.RegisterType<HandlerC>()
.AsSelf()
.As<IHandler>()
.IfNotRegistered(typeof(HandlerB));

builder.RegisterType<Manager>()
.As<IManager>()
.OnlyIf(reg =>
reg.IsRegistered(new TypedService(typeof(IService))) &&
reg.IsRegistered(new TypedService(typeof(HandlerB))));

var container = builder.Build();

注册的配置
你可以使用 XML 或or 编程式配置 ("模块") 来提供注册的群组或者在运行时改变注册. 对于一些动态的注册的生成或者有条件的注册逻辑, 你可以使用 Autofac 模块 .
动态提供的注册
Autofac模块是引入动态注册逻辑或简单切面功能的最简单的方法. 例如, 你可以使用一个模块动态地在被解析的服务上附加一个log4net logger实例.
如果想要完成更加动态的操作, 例如添加对新的隐式关系类型的支持, 你可以在高级概念章节查看注册源模块.

猜你喜欢