Official Autofac documentation link:
https://autofaccn.readthedocs.io/zh/latest/index.html
This article mainly discusses how to use the Autofac framework to complete dependency injection and other operations without diving into theory.
Using Autofac
We conduct tests and practices in a .NET Core console application.
1. Simple Practice
First, we add an interface and its implementation:
public interface IMyService { }
public class MyService : IMyService { }
Then, we register and build the container in the Main method:
class Program
{
private static IContainer Container;
static void Main(string[] args)
{
// Create the container builder
var builder = new ContainerBuilder();
// Register components
builder.RegisterType<MyService>().As<IMyService>();
// ...
// Build the container
Container = builder.Build();
}
}
We can then use it like this:
public static void Test()
{
// Lifecycle management
using (ILifetimeScope scope = Container.BeginLifetimeScope())
{
// Get instance
IMyService myService = scope.Resolve<IMyService>();
}
}
.As() is used to expose the service of a component.
This is a simple usage of Autofac.
Next, we will discuss more detailed usage and practices.
2. Registering Components
Previously, we used the ContainerBuilder object to register components and inform the container which components expose which services.
There are many ways to register components. In our previous example, we used reflection to register by passing a generic parameter:
.RegisterType<MyService>()
Or inject via type (Type):
builder.RegisterType(typeof(MyService)).As<IMyService>();
Of course, components registered through reflection will automatically inject the appropriate constructor for you.
You can also specify which constructor to use while instantiating the component using the UsingConstructor method:
builder.RegisterType<MyComponent>()
.UsingConstructor(typeof(ILogger), typeof(IConfigReader));
We can also pre-register instances:
MyService t = new MyService();
builder.RegisterInstance(t).As<IMyService>();
This will create a singleton application.
However, since RegisterInstance(t) will keep a reference to t, it means this instance is registered in the container.
Of course, you can use a lambda expression tree to create a new instance:
builder.Register(c => new MyService()).As<IMyService>();
This will avoid external references.
If you do not want this, you can use the ExternallyOwned method, which will create a new instance in the container. This is easy to understand if you are familiar with AutoMapper.
builder.RegisterInstance(t).As<IMyService>().ExternallyOwned();
3. Lambda Registration of Components
If a type's constructor depends on another interface, registering this type as a component can be more complex, and we can use a lambda expression to register the component.
Here are several interfaces and types:
public interface IA { }
public class A : IA { }
public interface IB { }
public class B : IB
{
private IA _a;
public B(IA a)
{
_a = a;
}
}
We can register type A first and then register type B:
builder.RegisterType<A>().As<IA>();
builder.Register(c => new B(c.Resolve<IA>()));
Of course, expressions are used here for convenience. You could also use:
builder.RegisterType<A>().As<IA>();
builder.RegisterType<B>().As<IB>();
When instantiating type B, the constructor will be automatically injected.
4. Registering Generics
If you need to register a generic type:
public interface IA { }
public class A<T> : IA { }
You can use RegisterGeneric to register the generic component:
builder.RegisterGeneric(typeof(A<>)).As<IA>();
Of course, if IA is also generic, use .As(typeof(IA)).
5. Property Injection
When registering components, using the PropertiesAutowired method will automatically inject properties when the container creates an instance.
The following are types:
public interface IA { }
public class A : IA { }
public interface IB { }
public class B : IB
{
public IA A { get; set; }
}
Registering:
builder.RegisterType<A>().As<IA>();
builder.RegisterType<B>().PropertiesAutowired().As<IB>();
Then, the container will automatically inject dependencies into the properties of type B.
Of course, this will inject dependencies into every property of the type.
If we only want to inject a specific property, we can use the WithProperty method, for example:
builder.RegisterType<B>().WithProperty("A", new A()).As<IB>();
6. Resolving Services
After registering components, call the Build() method to generate the container (IContainer).
Then, use the Resolve method to resolve services within its lifecycle.
Referring to previous examples:
using (ILifetimeScope scope = Container.BeginLifetimeScope())
{
// Get instance
IMyService myService = scope.Resolve<IMyService>();
}
Note that instances are resolved from the lifecycle (ILifetimeScope scope) rather than from the container (IContainer).
If you want to know whether a service has already been registered, you can use ResolveOptional() or TryResolve() methods:
using (ILifetimeScope scope = Container.BeginLifetimeScope())
{
IB b;
// Get instance
if (scope.TryResolve<IB>(out b))
{
}
}
You can also pass parameters during resolution to control which constructors the container should use when instantiating types.
Autofac provides various mechanisms for parameter matching:
- NamedParameter - matches target parameters by name
- TypedParameter - matches target parameters by type (requires matching the specific type)
- ResolvedParameter - flexible parameter matching
Example:
namespace AutofacTest
{
public interface IA { }
public class A : IA
{
public A(string a, string b) { Console.WriteLine($"a = {a}, b = {b}"); }
}
class Program
{
private static IContainer Container;
static void Main(string[] args)
{
// Create the container builder
var builder = new ContainerBuilder();
builder.RegisterType<A>().As<IA>();
// Build the container
Container = builder.Build();
Test();
}
public static void Test()
{
// Lifecycle management
using (ILifetimeScope scope = Container.BeginLifetimeScope())
{
IA b = scope.Resolve<IA>(new NamedParameter("a", "Test"), new NamedParameter("b", "Test"));
}
}
}
Or change it to:
IA b = scope.Resolve<IA>(new TypedParameter(typeof(string), "Test"), new TypedParameter(typeof(string), "Test"));
Additionally, Autofac also supports various types of service resolutions such as:
- Direct dependency (B)
- Lazy instantiation (Lazy)
- Controlled lifetime (Owned)
- Dynamic instantiation (Func)
- Parameterized instantiation (Func)
- Enumerable types (IEnumerable, IList, ICollection)
- Metadata interrogation (Meta, Meta)
- Keyed service lookup (IIndex)
7. Lifetimes
For more information about lifetimes, you can refer to: https://autofaccn.readthedocs.io/zh/latest/lifetime/index.html
As we saw earlier, to get an instance, we used:
using (ILifetimeScope scope = Container.BeginLifetimeScope())
{
}
BeginLifetimeScope creates a lifetime scope that is disposable and can track the disposal of components.
You can release the lifecycle using Dispose() or the using{} form.
You can also:
using (ILifetimeScope scope = Container.BeginLifetimeScope())
{
using (ILifetimeScope sc = scope.BeginLifetimeScope())
{
}
}
8. Instance Scopes
The scope of an instance determines how instances of the same exposed service are shared across multiple requests. The component's scope is determined when the component is registered, and then explicitly calling Resolve() will invoke specific behaviors (singleton, etc.).
8.1 One dependency one instance
In .NET's default dependency injection framework, this is referred to as 'transient' or 'factory', where a different instance is returned for each request. This is the default mode in Autofac.
You can also explicitly declare it using InstancePerDependency:
builder.RegisterType<Worker>().InstancePerDependency();
8.2 Single Instance
The SingleInstance method can be used to register a component as a single instance:
builder.RegisterType<Worker>().SingleInstance();
8.3 Lifecycle Scope Instances
Using InstancePerLifetimeScope allows you to ensure that the same instance is used within a lifetime scope.
Additionally, nested lifetime scopes are different, for example in the following case, the output is True,False.
using (ILifetimeScope scope = Container.BeginLifetimeScope())
{
IA b = scope.Resolve<IA>();
IA bb = scope.Resolve<IA>();
Console.WriteLine(b == bb);
using (ILifetimeScope sc = scope.BeginLifetimeScope())
{
IA bbb = sc.Resolve<IA>();
Console.WriteLine(b == bbb);
}
}
In addition, Autofac has other methods for scope management; please click the link to learn more: https://autofaccn.readthedocs.io/zh/latest/lifetime/instance-scope.html
9. Other Knowledge to Learn About Autofac
Autofac is a powerful framework, and this article only covers the basic introductory parts. There are other complex knowledge points with higher flexibility such as:
For further study, please refer to the documentation.
ASP.NET Core
In ASP.NET Core, there are significant differences between versions 2.x and 3.x; this section uses 3.x as an example.
1. Default Dependency Injection
In ASP.NET Core, the default dependency injection can be done by using the ConfigureServices method, where you can register services.
For example:
public void ConfigureServices(IServiceCollection services)
{
services.AddTransient<IA, A>();
}
2. Using Autofac
If you want to use Autofac as the dependency injection container in ASP.NET Core, you also need to install the NuGet package named Microsoft.Extensions.DependencyInjection.Abstractions.
。
Then add the following in the Host of the Program:
.UseServiceProviderFactory(new AutofacServiceProviderFactory())
An example is as follows:
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.UseServiceProviderFactory(new AutofacServiceProviderFactory())
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup<Startup>();
});
Then in the Startup class, add the ConfigureContainer method, and register the required components in this method:
public void ConfigureContainer(ContainerBuilder builder)
{
builder.RegisterType<A>().As<IA>();
}
Finally, add the following in the ConfigureServices method:
services.AddOptions();
This allows you to use Autofac as the ASP.NET Core dependency injection container.
Complete code:
public void ConfigureServices(IServiceCollection services)
{
services.AddOptions();
services.AddControllers();
}
public void ConfigureContainer(ContainerBuilder builder)
{
builder.RegisterType<A>().As<IA>();
}
ABP
First, it is required that you create an ASP.NET Core program and then configure ABP by introducing the corresponding package. You can refer to https://docs.abp.io/zh-Hans/abp/latest/Getting-Started-AspNetCore-Application.
In ABP, you can directly inject using ConfigureServices by default. Here is an example:
public class AppModule : AbpModule
{
public override void ConfigureServices(ServiceConfigurationContext context)
{
context.Services.AddTransient<IA, A>();
}
}
context.Services is the IServiceCollection object.
Of course, ABP can also use Autofac as a dependency injection container.
To use Autofac in ABP, you need to reference the Volo.Abp.Autofac package.
Then add the [DependsOn(typeof(AbpAutofacModule))] attribute in the module.
[DependsOn(typeof(AbpAutofacModule))]
public class AppModule : AbpModule{}
Then in the ConfigureServices method of Startup, add the ABP module and set it to use Autofac.
public void ConfigureServices(IServiceCollection services)
{
services.AddApplication<BasicAspNetCoreApplication.AppModule>(options =>
{
options.UseAutofac();
});
}
文章评论