NopCommerce 4.9.3全栈开发实战 - 2.2 依赖注入容器配置与使用

1. 依赖注入概述

依赖注入（Dependency Injection，DI）是一种设计模式，它允许我们将对象的依赖关系从对象内部移出，由外部容器进行管理和注入。这种设计模式具有以下优势：

• *降低耦合：对象不再直接创建和管理依赖，而是通过构造函数或属性获取- *提高可测试：可以轻松替换依赖实现，便于编写单元测试
• *增强可维护：依赖关系集中管理，便于修改和扩展性- 支持依赖倒置原则：高层模块不依赖于低层模块，而是依赖于抽
  NopCommerce广泛使用依赖注入模式，默认使用ASP.NET Core内置的依赖注入容器，同时也支持Autofac等第三方容器）

2. ASP.NET Core内置DI容器

ASP.NET Core内置了一个轻量级的依赖注入容器，支持构造函数注入、属性注入和方法注入。NopCommerce默认使用这个内置容器，同时也提供了对Autofac的支持）

2.1 服务生命周期

ASP.NET Core的依赖注入容器支持三种服务生命周期：

2.2 服务注册方法

ASP.NET Core的依赖注入容器提供了以下服务注册方法）

3. NopCommerce的DI配置

NopCommerce的依赖注入配置主要在以下几个地方案

1. Startup.cs：ASP.NET Core应用程序的启动配置2. NopEngine.cs：NopCommerce的核心引擎，负责初始化应）3. DependencyRegistrar.cs：插件和模块的依赖注）

3.1 Startup.cs中的DI配置

// Startup.cs - 应用程序启动配置
public void ConfigureServices(IServiceCollection services)
{
    // 配置应用设置
    services.ConfigureApplicationSettings(Configuration);
    
    // 配置身份验证
    services.ConfigureAuthentication(Configuration);
    
    // 配置MVC
    services.ConfigureMvc();
    
    // 配置Swagger
    services.ConfigureSwagger();
    
    // 注册Nop引擎
    services.AddSingleton<IEngine, NopEngine>();
    
    // 注册HTTP上下文访问器
    services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
    
    // 注册缓存管理论    services.AddSingleton<IStaticCacheManager, MemoryCacheManager>();
    services.AddScoped<ICacheManager, PerRequestCacheManager>();
    
    // 初始化引擎并注册依赖
    var engine = services.BuildServiceProvider().GetRequiredService<IEngine>();
    engine.Initialize(services);
    
    // 注册控制）    services.AddControllersWithViews();
    
    // 注册Razor页面
    services.AddRazorPages();
}

3.2 NopEngine中的DI配置

// NopEngine.cs - 核心引擎实现
public void Initialize(IServiceCollection services)
{
    // 注册依赖注入
    RegisterDependencies(services);
    
    // 初始化插）    InitializePlugins(services);
    
    // 初始化任）    InitializeTasks(services);
    
    // 初始化缓存    InitializeCache(services);
}

protected virtual void RegisterDependencies(IServiceCollection services)
{
    // 注册数据层服务    services.AddScoped(typeof(IRepository<>), typeof(EntityRepository<>));
    
    // 注册事件发布）    services.AddScoped<IEventPublisher, EventPublisher>();
    
    // 注册事件消费）    RegisterEventConsumers(services);
    
    // 注册服务层服务    RegisterServices(services);
    
    // 注册Web层服务    RegisterWebServices(services);
}

3.3 DependencyRegistrar中的DI配置

NopCommerce使用DependencyRegistrar模式来注册插件和模块的依赖。每个插件或模块可以实现IDependencyRegistrar接口，在应用启动时注册自己的依赖）

// 示例：产品服务依赖注）public class ProductDependencyRegistrar : IDependencyRegistrar
{
    public int Order => 1;
    
    public void Register(IServiceCollection services, IConfiguration configuration)
    {
        // 注册产品服务
        services.AddScoped<IProductService, ProductService>();
        services.AddScoped<IProductAttributeService, ProductAttributeService>();
        services.AddScoped<IProductTagService, ProductTagService>();
        
        // 注册产品模型工厂
        services.AddScoped<IProductModelFactory, ProductModelFactory>();
    }
}

4. 使用依赖注入

在NopCommerce中，依赖注入主要通过构造函数注入实现，这是最推荐的注入方式）

4.1 构造函数注）

构造函数注入是NopCommerce中最常用的依赖注入方式，对象通过构造函数接收依赖）

// 示例：产品控制器
public partial class ProductController : BasePublicController
{
    private readonly IProductService _productService;
    private readonly ICategoryService _categoryService;
    private readonly IProductModelFactory _productModelFactory;
    
    // 构造函数注入依）    public ProductController(IProductService productService,
        ICategoryService categoryService,
        IProductModelFactory productModelFactory)
    {
        _productService = productService;
        _categoryService = categoryService;
        _productModelFactory = productModelFactory;
    }
    
    // 控制器方案..
}

// 示例：产品服务public partial class ProductService : IProductService
{
    private readonly IRepository<Product> _productRepository;
    private readonly IEventPublisher _eventPublisher;
    
    // 构造函数注入依）    public ProductService(IRepository<Product> productRepository,
        IEventPublisher eventPublisher)
    {
        _productRepository = productRepository;
        _eventPublisher = eventPublisher;
    }
    
    // 服务方法...
}

4.2 属性注）

属性注入是通过设置对象的属性来注入依赖，在NopCommerce中使用较少，主要用于某些特殊场景）

// 示例：属性注）public partial class ProductService : IProductService
{
    // 属性注入依）    [Autowired]
    public IRepository<Product> ProductRepository { get; set; }
    
    [Autowired]
    public IEventPublisher EventPublisher { get; set; }
    
    // 服务方法...
}

4.3 方法注入

方法注入是通过调用对象的方法来注入依赖，在NopCommerce中使用较少）

// 示例：方法注）public partial class ProductService : IProductService
{
    private IRepository<Product> _productRepository;
    private IEventPublisher _eventPublisher;
    
    // 方法注入依赖
    [Inject]
    public void Initialize(IRepository<Product> productRepository,
        IEventPublisher eventPublisher)
    {
        _productRepository = productRepository;
        _eventPublisher = eventPublisher;
    }
    
    // 服务方法...
}

5. 解析服务

在某些情况下，我们需要手动解析服务，而不是通过依赖注入获取。NopCommerce提供了多种方式来解析服务）

5.1 使用IServiceProvider解析服务

// 示例：使用IServiceProvider解析服务
public partial class ProductController : BasePublicController
{
    private readonly IServiceProvider _serviceProvider;
    
    public ProductController(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }
    
    public async Task<IActionResult> ProductDetails(int productId)
    {
        // 手动解析产品服务
        var productService = _serviceProvider.GetRequiredService<IProductService>();
        var product = await productService.GetProductByIdAsync(productId);
        
        // 其他逻辑...
    }
}

5.2 使用IEngine解析服务

NopCommerce的核心引擎IEngine也提供了解析服务的方法）

// 示例：使用IEngine解析服务
public partial class ProductController : BasePublicController
{
    private readonly IEngine _engine;
    
    public ProductController(IEngine engine)
    {
        _engine = engine;
    }
    
    public async Task<IActionResult> ProductDetails(int productId)
    {
        // 手动解析产品服务
        var productService = _engine.Resolve<IProductService>();
        var product = await productService.GetProductByIdAsync(productId);
        
        // 其他逻辑...
    }
}

5.3 使用HttpContext解析服务

在控制器或视图中，可以通过HttpContext访问RequestServices来解析服务）

// 示例：在控制器中使用HttpContext解析服务
public async Task<IActionResult> ProductDetails(int productId)
{
    // 从HttpContext解析服务
    var productService = HttpContext.RequestServices.GetRequiredService<IProductService>();
    var product = await productService.GetProductByIdAsync(productId);
    
    // 其他逻辑...
}

// 示例：在视图中解析服务@inject IProductService ProductService

<div>
    @{ var product = ProductService.GetProductById(1); }
    <h2>@product.Name</h2>
    <p>@product.Price</p>
</div>

6. 配置Autofac容器

虽然NopCommerce默认使用ASP.NET Core内置的依赖注入容器，但也提供了对Autofac的支持。Autofac是一个功能强大的第三方依赖注入容器，支持更多高级功能，如属性注入、方法注入、动态代理等）

6.1 安装Autofac

要使用Autofac，需要先安装相关包：

dotnet add package Autofac

6.2 配置Autofac

// Startup.cs - 配置Autofac
public void ConfigureServices(IServiceCollection services)
{
    // 其他配置...
    
    // 使用Autofac服务提供工厂
    services.AddAutofac();
}

public void ConfigureContainer(ContainerBuilder builder)
{
    // 注册Autofac模块
    builder.RegisterModule(new NopAutofacModule());
    
    // 注册自定义服务    builder.RegisterType<ProductService>().As<IProductService>().InstancePerLifetimeScope();
    builder.RegisterType<OrderService>().As<IOrderService>().InstancePerLifetimeScope();
}

6.3 NopAutofacModule

NopCommerce提供了一个Autofac模块，用于注册核心服务）

// NopAutofacModule.cs
public class NopAutofacModule : Module
{
    protected override void Load(ContainerBuilder builder)
    {
        // 注册仓储
        builder.RegisterGeneric(typeof(EntityRepository<>)).As(typeof(IRepository<>)).InstancePerLifetimeScope();
        
        // 注册事件发布）        builder.RegisterType<EventPublisher>().As<IEventPublisher>().InstancePerLifetimeScope();
        
        // 注册服务层服务        builder.RegisterAssemblyTypes(typeof(ProductService).Assembly)
            .Where(t => t.Name.EndsWith("Service"))
            .AsImplementedInterfaces()
            .InstancePerLifetimeScope();
        
        // 注册Web层服务        builder.RegisterAssemblyTypes(typeof(ProductModelFactory).Assembly)
            .Where(t => t.Name.EndsWith("ModelFactory"))
            .AsImplementedInterfaces()
            .InstancePerLifetimeScope();
    }
}

7. 依赖注入最佳实现

在NopCommerce开发中，建议遵循以下依赖注入最佳实践：

1. **优先使用构造函数注）：构造函数注入是最安全的注入方式，确保对象在创建时就拥有所有必需的依）2. **避免属性注）：属性注入可能导致对象在缺少依赖的情况下被创建，增加运行时错误的风险
2. 使用合适的服务生命周期：根据服务的性质选择合适的生命周期，避免滥用Singleton
3. *依赖于抽象，而不是具体实现：使用接口或抽象类作为依赖类型，而不是具体类
4. *避免服务定位器模式：尽量通过依赖注入获取服务，而不是手动解）6. **保持构造函数简）*：构造函数中的依赖数量不宜过多，一般不超过5）7. 为插件和模块使用DependencyRegistrar：通过实现IDependencyRegistrar接口注册插件的依）8. 编写可测试的代码：设计服务时考虑可测试性，便于替换依赖实现

8. 常见问题与解决方案

8.1 循环依赖

问题：两个或多个服务相互依赖，导致依赖注入容器无法解）
解决方案）- 重构代码，打破循环依）- 使用属性注入替代构造函数注）- 使用Lazy延迟初始化依）
示例）

// 循环依赖示例
public class ServiceA : IServiceA
{
    private readonly IServiceB _serviceB;
    
    public ServiceA(IServiceB serviceB) => _serviceB = serviceB;
}

public class ServiceB : IServiceB
{
    private readonly IServiceA _serviceA;
    
    public ServiceB(IServiceA serviceA) => _serviceA = serviceA;
}

// 解决方案1：使用Lazy<T>
public class ServiceA : IServiceA
{
    private readonly Lazy<IServiceB> _serviceB;
    
    public ServiceA(Lazy<IServiceB> serviceB) => _serviceB = serviceB;
    
    public void DoSomething() => _serviceB.Value.DoSomethingElse();
}

// 解决方案2：使用属性注）public class ServiceB : IServiceB
{
    public IServiceA ServiceA { get; set; }
    
    public ServiceB() { }
}

8.2 服务未注）

问题：尝试解析服务时，依赖注入容器抛）No service for type ‘X’ has been registered"异常

解决方案）- 检查服务是否已正确注册

• 检查服务类型和接口是否匹配
• 检查服务注册的生命周期是否正确

8.3 服务生命周期问题

问题：服务实例在不适当的时机被创建或释）
解决方案）- 确保为服务选择了合适的生命周期

• 避免在Singleton服务中注入Scoped或Transient服务
• 注意服务的释放时

9. 总结

依赖注入是NopCommerce架构的核心组成部分，它提高了代码的可测试性、可维护性和可扩展性。NopCommerce默认使用ASP.NET Core内置的依赖注入容器，同时也支持Autofac等第三方容器）
在开发NopCommerce应用时，建议遵循依赖注入的最佳实践，优先使用构造函数注入，依赖于抽象，选择合适的服务生命周期。通过合理使用依赖注入，可以编写出高质量、可维护的代码，提高开发效率和代码质量
下一篇文章将详细介绍NopCommerce的仓储模式实现，帮助开发者深入理解数据访问层的设计和使用