重构与优化之依赖注入重构

依赖注入（Dependency Injection，DI）是一种设计模式，用于解耦组件间的依赖关系。通过依赖注入，可以提高代码的可测试性、可维护性和可扩展性。AI编程工具可以帮助开发者识别依赖问题并进行依赖注入重构。

1. 依赖注入概述

依赖注入是控制反转（IoC）的一种实现方式，其核心思想是：

• 依赖抽象而非具体实现：通过接口或抽象类定义依赖
• 外部注入依赖：依赖由外部容器或调用者注入，而非组件自行创建
• 解耦组件关系：组件之间通过抽象接口交互，降低耦合度

2. 依赖注入的三种方式

2.1 构造函数注入

通过构造函数注入依赖，是最推荐的方式：

public class OrderService
{
    private readonly IOrderRepository _repository;
    private readonly INotificationService _notificationService;
    
    public OrderService(IOrderRepository repository, 
                       INotificationService notificationService)
    {
        _repository = repository;
        _notificationService = notificationService;
    }
}

2.2 属性注入

通过属性注入依赖，适用于可选依赖：

public class OrderService
{
    public ILogger Logger { get; set; }
    
    public void ProcessOrder(Order order)
    {
        Logger?.Log($"Processing order: {order.Id}");
    }
}

2.3 方法注入

通过方法参数注入依赖，适用于临时依赖：

public class OrderService
{
    public void ProcessOrder(Order order, IValidationService validator)
    {
        validator.Validate(order);
    }
}

3. 常见的依赖问题

3.1 硬编码依赖

组件内部直接实例化依赖对象：

// 坏味道：硬编码依赖
public class OrderService
{
    private readonly OrderRepository _repository = new OrderRepository();
    private readonly EmailService _emailService = new EmailService();
}

3.2 依赖具体类型

依赖具体类型而非抽象接口：

// 坏味道：依赖具体类型
public class OrderService
{
    private readonly SqlOrderRepository _repository;
    
    public OrderService(SqlOrderRepository repository)
    {
        _repository = repository;
    }
}

3.3 循环依赖

组件之间相互依赖：

// 坏味道：循环依赖
public class ServiceA { public ServiceB B { get; } }
public class ServiceB { public ServiceA A { get; } }

3.4 过多依赖

一个类依赖过多的组件，说明职责可能不清晰：

// 坏味道：过多依赖
public class OrderService
{
    public OrderService(IRepository repo, IValidator val, 
                       ILogger log, INotifier notif, ICache cache, 
                       ISecurity sec, IMetrics met) { }
}

4. AI辅助依赖注入重构

4.1 识别依赖注入机会

请分析以下代码，识别其中的依赖注入机会：

[粘贴代码]

请列出：
1. 需要重构的依赖关系
2. 建议的注入方式（构造函数/属性/方法）
3. 重构后的代码示例

4.2 生成依赖注入配置

请根据以下服务类生成ASP.NET Core的依赖注入配置：

[粘贴服务类代码]

要求：
1. 为每个服务配置合适的生命周期（Singleton/Scoped/Transient）
2. 生成Program.cs中的注册代码
3. 如果需要接口，请定义接口

5. 依赖注入重构流程

flowchart TD
    A[识别依赖问题] --> B[定义抽象接口]
    B --> C[重构构造函数注入]
    C --> D[配置DI容器]
    D --> E[编写单元测试]
    E --> F[验证测试通过]
    F --> G[优化调整]
    G --> H[完成重构]

6. 依赖注入重构示例

6.1 重构前：硬编码依赖

public class ProductService
{
    private readonly ProductDbContext _dbContext = new ProductDbContext();
    private readonly FileLogger _logger = new FileLogger();
    
    public Product GetById(int id)
    {
        _logger.Log($"Getting product {id}");
        return _dbContext.Products.Find(id);
    }
}

6.2 重构后：依赖注入

public interface IProductRepository
{
    Product GetById(int id);
}

public interface ILogger
{
    void Log(string message);
}

public class ProductService
{
    private readonly IProductRepository _repository;
    private readonly ILogger _logger;
    
    public ProductService(IProductRepository repository, ILogger logger)
    {
        _repository = repository;
        _logger = logger;
    }
    
    public Product GetById(int id)
    {
        _logger.Log($"Getting product {id}");
        return _repository.GetById(id);
    }
}

6.3 DI容器配置

// ASP.NET Core Program.cs
builder.Services.AddScoped<IProductRepository, ProductRepository>();
builder.Services.AddSingleton<ILogger, FileLogger>();
builder.Services.AddScoped<ProductService>();

7. 依赖注入最佳实践

• 优先使用构造函数注入：确保依赖在对象创建时就已就绪
• 依赖抽象而非具体类型：通过接口定义依赖关系
• 避免循环依赖：设计时注意组件间的依赖方向
• 控制依赖数量：一个类的依赖不应超过4-5个
• 合理选择生命周期：Singleton适合无状态服务，Scoped适合请求级别服务
• 使用DI容器：利用成熟的DI框架管理依赖

8. 依赖注入生命周期

9. 总结

依赖注入重构是提高代码可测试性和可维护性的重要手段。AI编程工具可以帮助开发者：

• 识别硬编码依赖和依赖具体类型的问题
• 生成接口定义和重构代码
• 配置DI容器注册
• 提供依赖注入最佳实践建议

通过合理应用依赖注入，可以使代码更加灵活、可测试和易于维护。