Autofac的几种方式

.net下优秀的IOC容器框架Autofac的使用方法，实例解析 - 知乎 (zhihu.com)

 

UseServiceProviderFactory(使用服务提供商) 是在 ASP.NET Core 中用来替换默认的依赖注入容器工厂的方法。
通过使用不同的容器工厂，可以使用第三方的依赖注入容器（如 Autofac、Ninject 等），以替代默认的 ASP.NET Core 依赖注入容器。

具体来说，UseServiceProviderFactory 方法接受一个实现了 IServiceProviderFactory<TContainerBuilder> 接口的容器工厂实例作为参数。
该接口定义了一个 CreateBuilder 方法，用于创建容器构建器，并在其上进行配置。
CreateBuilder 方法将在应用程序启动时被调用，用于创建容器构建器，以及在其中进行服务的注册和配置。

1.Main方法中代码

public static void Main(string[] args)
{
    var builder = WebApplication.CreateBuilder(args);
    // Add services to the container.
    //使用AutoFac 方式
    builder.Host.UseServiceProviderFactory(new AutofacServiceProviderFactory());

    builder.Services.AddControllers();
    // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
    builder.Services.AddEndpointsApiExplorer();    
    //Swagger UI
    builder.Services.AddSwaggerGen();

   //使用.NET Generic Host 中的 ConfigureContainer 方法来配置依赖注入容器。
   //在这里，使用了 Autofac 容器，因此使用的是 ContainerBuilder 类型。
   //具体来说，.Host.ConfigureContainer<ContainerBuilder>(x => { ... }) 这段代码表示在 Generic Host 的构建过程中，对依赖注入容器进行配置。
   //其中的 x 是一个 ContainerBuilder 类型的参数，用于注册依赖项
    //在代码中，通过 RegisterModule 方法注册了一个名为 TestCoreModule 的模块，这个模块实现了 Autofac 的 Module 类
    //在 TestCoreModule 中可以包含一些特定的服务注册逻辑，以便在整个应用程序中使用
    builder.Host.ConfigureContainer<ContainerBuilder>(x =>
    {
        //TestCoreModule 是一个实现了AutoFac.Module 的一个类Module
        x.RegisterModule(new TestCoreModule());
    });

    var app = builder.Build();
    // Configure the HTTP request pipeline.
    if (app.Environment.IsDevelopment())
    {
        app.UseSwagger();
        app.UseSwaggerUI();
    }
    app.UseHttpsRedirection();
    app.UseAuthorization();
    app.MapControllers();
    app.Run();
}

2.TesCoreModule的实现

using Autofac;
namespace AutofacServiceDemo
{
    public class TestCoreModule: Module
    {
        protected override void Load(ContainerBuilder builder)
        {
            builder.RegisterType<SonCaseService>().As<ICaseService>().InstancePerLifetimeScope();
        }
    }
}

3：接口和派生类(业务层面)

namespace AutofacServiceDemo
{
    public interface ICaseService
    {
        string Ret();
    }

    public class SonCaseService : ICaseService
    {
        public string Ret()
        {
            return "我是实现类";
        }
    }
}

4：控制器层面

using Microsoft.AspNetCore.Mvc;

namespace AutofacServiceDemo.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class TestController : Controller
    {

        private readonly ICaseService _caseService;

        public TestController(ICaseService caseService)
        {
            _caseService = caseService;
        }

        [HttpPost()]
        public IActionResult Index(string id,string name)
        {
            var ret = _caseService.Ret();
            return Ok();
        }
    }
}

 

两种注册方式的区别：

public class TestCoreModule: Module
 {
     protected override void Load(ContainerBuilder builder)
     {
         builder.RegisterType<SonCaseService>().As<ICaseService>().SingleInstance();
     }
 }

public class DefaultWebApiModule : Module
{  
    private readonly Settings _settings;
    public DefaultWebApiModule(Settings settings)
    {
        _settings = settings; 
    }
    protected override void Load(ContainerBuilder builder)
    {
        builder.Register(p => _settings).SingleInstance();
    }
}

builder.Register 和 builder.RegisterType 都是 Autofac 容器中用于注册组件的方法，它们之间的区别在于使用方式和灵活性。
builder.Register：这个方法是一个通用的注册方法，可以用来注册任意类型的组件。您可以使用 lambda 表达式或委托来指定组件的创建逻辑。例如：
builder.Register(p => new MyService()).As<IMyService>().SingleInstance();
在上述示例中，我们使用 lambda 表达式来创建 MyService 类型的实例，并将其注册为 IMyService 接口的实现。通过 As 方法指定了接口和实现的对应关系，并通过 SingleInstance 方法将其设置为单例模式。

builder.RegisterType：这个方法是针对特定类型的注册方法，它会自动推断要注册的类型和实现的接口。例如：
builder.RegisterType<MyService>().AsImplementedInterfaces().SingleInstance();
在上述示例中，我们直接指定了要注册的类型 MyService，然后通过 AsImplementedInterfaces 方法将其实现的所有接口都注册到容器中，并通过 SingleInstance 方法将其设置为单例模式。

总的来说，builder.Register 提供了更大的灵活性，可以用于注册任意类型的组件，并且可以使用 lambda 表达式或委托来指定创建逻辑。而 builder.RegisterType 则更为简洁，适用于直接注册特定类型，并自动推断其实现的接口。