Autofac 3.5.2: 开始、注册与集成教程

5星 · 超过95%的资源需积分: 9 183 浏览量更新于2024-07-20 收藏 1.07MB PDF 举报

Autofac-3.5.2 是一个流行的依赖注入框架，用于.NET应用程序中的组件管理和配置。此版本提供了全面的教程、新功能概述和核心概念的讲解，旨在帮助开发者构建更加灵活和可管理的应用架构。 **1. Getting Started (入门)** 这部分介绍了如何在应用程序中集成Autofac。首先，结构化应用程序（1.1），包括了解如何添加Autofac的引用，确保其在整个项目中正确引用。然后，通过ApplicationStartup（1.2）来初始化依赖关系容器，通常在启动阶段配置和注册组件。ApplicationExecution（1.3）阶段涉及实际的服务获取和使用，以及进一步学习的选项（1.4）。 **2. What's New/ReleaseNotes (新功能/更新)** 这部分关注3.5.2版本的新特性和改进，概述了与前一版本相比的重大变更或优化，有助于用户了解性能提升或功能增强。 **3. Registering Components (注册组件)** 关键概念（3.1）包括组件注册的基础原理，如注册类型、接口和实例。通过传递参数（3.2）到注册过程，可以定制组件的行为。属性和方法注入（3.3）允许更高级别的控制，而assembly scanning（3.4）则提供了自动发现和注册组件的功能。 **4. Resolving Services (服务解析)** 如何向应用提供服务（4.1）是核心部分，包括如何在运行时根据需要传递参数。此外，还讨论了隐式关系类型（4.2），这对于理解服务之间的依赖关系至关重要。 **5. Controlling Scope and Lifetime (控制作用域和生命周期)** 这一章节涵盖了不同作用域（5.1，如LifetimeScopes）的使用，如何创建和管理实例（5.2，InstanceScope），以及组件的生命周期管理和垃圾回收（5.3，Disposal）。此外，还介绍了生命周期事件（5.4）和在应用程序启动时运行代码（5.5）的概念。 **6. Configuration (配置)** 配置选项丰富多样，包括XML配置（6.1）用于简洁地定义容器设置，以及模块化设计（6.2）以保持代码结构清晰。 **7. Application Integration (应用集成)** 特别关注的是Autofac与ASP.NET（7.1）的集成，这对于Web开发来说是一个重要的应用场景，能够简化服务注入和生命周期管理。 Autofac-3.5.2是一个强大的工具，帮助开发者在.NET项目中实现松耦合和可测试的架构。通过掌握这些核心概念和技术，开发人员可以更高效地构建和维护复杂的软件系统。务必遵守版权规定，支持正版资源。

CHAPTER 3

Registering Components

3.1 Registration Concepts

You register components with Autofac by creating a ContainerBuilder and informing the builder which compo-

nents expose which services.

Components can be created via reﬂection (by registering a speciﬁc .NET type or open generic); by providing a ready-

made instance (an instance of an object you created); or via lambda expression (an anonymous function that executes

to instantiate your object). ContainerBuilder has a family of Register() methods that allow you to set these

up.

Each component exposes one or more services that are wired up using the As() methods on ContainerBuilder.

// Create the builder with which components/services are registered.

var builder = new ContainerBuilder();

// Register types that expose interfaces...

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

// Register instances of objects you create...

var output = new StringWriter();

builder.RegisterInstance(output).As<TextWriter>();

// Register expressions that execute to create objects...

builder.Register(c => new ConfigReader("mysection")).As<IConfigReader>();

// Build the container to finalize registrations

// and prepare for object resolution.

var container = builder.Build();

// Now you can resolve services using Autofac. For example,

// this line will execute the lambda expression registered

// to the IConfigReader service.

using(var scope = container.BeginLifetimeScope())

{

var reader = container.Resolve<IConfigReader>();

}

3.1.1 Reﬂection Components

Components generated by reﬂection are typically registered by type:

整理 by 懒惰的小毛驴 http://www.wit-x.com

Autofac Documentation, Release 3.3

var builder = new ContainerBuilder();

builder.RegisterType<ConsoleLogger>();

builder.RegisterType(typeof(ConfigReader));

When using reﬂection-based components, Autofac automatically uses the constructor for your class with the most

parameters that are able to be obtained from the container.

For example, say you have a class with three constructors like this:

public class MyComponent

{

public MyComponent() { /

...

/ }

public MyComponent(ILogger logger) { /

...

/ }

public MyComponent(ILogger logger, IConfigReader reader) { /

...

/ }

}

Now say you register components and services in your container like this:

var builder = new ContainerBuilder();

builder.RegisterType<MyComponent>();

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

var container = builder.Build();

using(var scope = container.BeginLifetimeScope())

{

var component = container.Resolve<MyComponent>();

}

When you resolve your component, Autofac will see that you have an ILogger registered, but you don’t have an

IConfigReader registered. In that case, the second constructor will be chosen since that’s the one with the most

parameters that can be found in the container.

You can manually choose a particular constructor to use and override the automatic choice by registering your compo-

nent with the UsingConstructor method and a list of types representing the parameter types in the constructor:

builder.RegisterType<MyComponent>()

.UsingConstructor(typeof(ILogger), typeof(IConfigReader));

Note that you will still need to have the requisite parameters available at resolution time or there will be an error when

you try to resolve the object. You can pass parameters at registration time or you can pass them at resolve time.

An important note on reﬂection-based components: Any component type you register via RegisterType must

be a concrete type. While components can expose abstract classes or interfaces as services, you can’t register an

abstract/interface component. It makes sense if you think about it: behind the scenes, Autofac is creating an instance of

the thing you’re registering. You can’t “new up” an abstract class or an interface. You have to have an implementation,

right?

3.1.2 Instance Components

In some cases, you may want to pre-generate an instance of an object and add it to the container for use by registered

components. You can do this using the RegisterInstance method:

var output = new StringWriter();

builder.RegisterInstance(output).As<TextWriter>();

Something to consider when you do this is that Autofac automatically handles disposal of registered components and

you may want to control the lifetime yourself rather than having Autofac call Dispose on your object for you. In

that case, you need to register the instance with the ExternallyOwned method:

12 Chapter 3. Registering Components

整理 by 懒惰的小毛驴 http://www.wit-x.com

Autofac Documentation, Release 3.3

var output = new StringWriter();

builder.RegisterInstance(output)

.As<TextWriter>()

.ExternallyOwned();

Registering provided instances is also handy when integrating Autofac into an existing application where a singleton

instance already exists and needs to be used by components in the container. Rather than tying those components

directly to the singleton, it can be registered with the container as an instance:

builder.RegisterInstance(MySingleton.Instance).ExternallyOwned();

This ensures that the static singleton can eventually be eliminated and replaced with a container-managed one.

The default service exposed by an instance is the concrete type of the instance. See “Services vs. Components,” below.

3.1.3 Lambda Expression Components

Reﬂection is a pretty good default choice for component creation. Things get messy, though, when component creation

logic goes beyond a simple constructor call.

Autofac can accept a delegate or lambda expression to be used as a component creator:

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

The parameter c provided to the expression is the component context (an IComponentContext object) in which

the component is being created. You can use this to resolve other values from the container to assist in creating your

component. It is important to use this rather than a closure to access the container so that deterministic disposal

and nested containers can be supported correctly.

Additional dependencies can be satisﬁed using this context parameter - in the example, A requires a constructor

parameter of type B that may have additional dependencies.

The default service provided by an expression-created component is the inferred return type of the expression.

Below are some examples of requirements met poorly by reﬂective component creation but nicely addressed by lambda

expressions.

Complex Parameters

Constructor parameters can’t always be declared with simple constant values. Rather than puzzling over how to

construct a value of a certain type using an XML conﬁguration syntax, use code:

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

(Of course, session expiry is probably something you’d want to specify in a conﬁguration ﬁle - but you get the gist ;))

Property Injection

While Autofac offers a more ﬁrst-class approach to property injection, you can use expressions and property initializers

to populate properties as well:

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

The ResolveOptional method will try to resolve the value but won’t throw an exception if the service isn’t

registered. (You will still get an exception if the service is registered but can’t properly be resolved.) This is one of the

options for resolving a service.

3.1. Registration Concepts 13

整理 by 懒惰的小毛驴 http://www.wit-x.com

Autofac Documentation, Release 3.3

Property injection is not recommended in the majority of cases. Alternatives like the Null Object pattern, over-

loaded constructors or constructor parameter default values make it possible to create cleaner, “immutable” compo-

nents with optional dependencies using constructor injection.

Selection of an Implementation by Parameter Value

One of the great beneﬁts of isolating component creation is that the concrete type can be varied. This is often done at

runtime, not just conﬁguration time:

builder.Register<CreditCard>(

(c, p) =>

{

var accountId = p.Named<string>("accountId");

if (accountId.StartsWith("9"))

{

return new GoldCard(accountId);

}

else

{

return new StandardCard(accountId);

}

});

In this example, CreditCard is implemented by two classes, GoldCard and StandardCard - which class is

instantiated depends on the account ID provided at runtime.

Parameters are provided to the creation function through an optional second parameter named p in this example.

Using this registration would look like:

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

A cleaner, type-safe syntax can be achieved if a delegate to create CreditCard instances is declared and a delegate

factory is used.

3.1.4 Open Generic Components

Autofac supports open generic types. Use the RegisterGeneric() builder method:

builder.RegisterGeneric(typeof(NHibernateRepository<>))

.As(typeof(IRepository<>))

.InstancePerLifetimeScope();

When a matching service type is requested from the container, Autofac will map this to an equivalent closed version

of the implementation type:

// Autofac will return an NHibernateRepository<Task>

var tasks = container.Resolve<IRepository<Task>>();

Registration of a specialized service type (e.g. IRepository<Person>) will override the open generic version.

3.1.5 Services vs. Components

When you register components, you have to tell Autofac which services that component exposes. By default, most

registrations will just expose themselves as the type registered:

14 Chapter 3. Registering Components

整理 by 懒惰的小毛驴 http://www.wit-x.com

剩余145页未读，继续阅读

lxzlll2010

粉丝: 1
资源: 10

Autofac 3.5.2: 开始、注册与集成教程

MVC+ICO-AutoFac搭建的项目框架DEMO 紧供学习之用

webform autofac

Autofac.3.5.2

autofac-unity5

EF-Code-First-MySQL-Autofac-MVC5

autofac-conditional-injection:该项目演示了用于高级构造函数注入的 Autofac.Module

Autofac-2.6.3.862-NET40.zip

Autofac.4.0.0-beta6-110

Autofac.4.0.0-beta5-90

Autofac.4.0.0-beta7-130

最新资源