一、依赖注入基础概念
在编程的世界里，依赖注入（Dependency Injection，简称 DI）是一种设计模式，它就像是一个贴心的助手，能帮我们把各个组件之间的依赖关系管理得井井有条。在 .NET Core 里，依赖注入更是被广泛应用，它让代码的可维护性和可测试性大大提高。
咱们先来说说依赖是啥。简单来讲，当一个类需要用到另一个类的功能时，就产生了依赖关系。比如有一个 OrderService 类，它要调用 ProductRepository 类来获取商品信息，那么 OrderService 就依赖于 ProductRepository。
依赖注入就是把这种依赖关系从代码内部转移到外部，通过构造函数、属性或者方法参数等方式将依赖对象传递进来。这样做的好处可多啦，代码的耦合度降低了，不同的组件可以独立开发、测试和维护。
二、.NET Core 中依赖注入的使用示例
下面我们用 C# 这个 .NET Core 常用的技术栈来写个简单的示例。
1. 定义接口和实现类
首先，我们定义一个 IProductRepository 接口和它的实现类 ProductRepository。
// 定义产品仓库接口
public interface IProductRepository
{
string GetProductName();
}
// 实现产品仓库接口
public class ProductRepository : IProductRepository
{
public string GetProductName()
{
return "iPhone";
}
}
这里 IProductRepository 接口定义了一个获取产品名称的方法，ProductRepository 类实现了这个接口。
2. 定义服务类
接着，我们定义一个 OrderService 类，它依赖于 IProductRepository。
// 订单服务类，依赖于 IProductRepository
public class OrderService
{
private readonly IProductRepository _productRepository;
public OrderService(IProductRepository productRepository)
{
_productRepository = productRepository;
}
public string CreateOrder()
{
string productName = _productRepository.GetProductName();
return $"Order created for {productName}";
}
}
在 OrderService 类的构造函数中，我们通过参数注入了 IProductRepository 对象。
3. 配置依赖注入
在 .NET Core 的 Startup.cs 文件中，我们可以配置依赖注入。
public void ConfigureServices(IServiceCollection services)
{
// 注册 IProductRepository 接口和它的实现类
services.AddScoped<IProductRepository, ProductRepository>();
// 注册 OrderService 类
services.AddScoped<OrderService>();
}
这里使用 AddScoped 方法将 IProductRepository 和 ProductRepository 进行了注册，并且注册了 OrderService 类。AddScoped 表示在每个请求的生命周期内只创建一个实例。
4. 使用依赖注入
在控制器中，我们可以使用依赖注入来获取 OrderService 实例。
[ApiController]
[Route("[controller]")]
public class OrderController : ControllerBase
{
private readonly OrderService _orderService;
public OrderController(OrderService orderService)
{
_orderService = orderService;
}
[HttpGet]
public string Get()
{
return _orderService.CreateOrder();
}
}
在 OrderController 的构造函数中，我们通过参数注入了 OrderService 对象，然后在 Get 方法中调用 CreateOrder 方法。
三、常见问题及解决方案
1. 依赖注入未正确配置
有时候我们可能会忘记在 Startup.cs 中注册依赖，或者注册的方式不对，导致运行时出现 InvalidOperationException 异常。
问题示例：
// 忘记注册 IProductRepository
public void ConfigureServices(IServiceCollection services)
{
services.AddScoped<OrderService>();
}
当我们尝试在控制器中注入 OrderService 时，由于 IProductRepository 没有注册，就会抛出异常。
解决方案： 确保所有的依赖都正确注册。
public void ConfigureServices(IServiceCollection services)
{
services.AddScoped<IProductRepository, ProductRepository>();
services.AddScoped<OrderService>();
}
2. 生命周期管理不当
在 .NET Core 中，依赖注入有三种生命周期：单例（Singleton）、作用域（Scoped）和瞬态（Transient）。如果生命周期管理不当，可能会导致内存泄漏或者数据不一致等问题。
单例（Singleton）： 单例模式下，整个应用程序生命周期内只会创建一个实例。
services.AddSingleton<IProductRepository, ProductRepository>();
适用于那些不依赖于请求上下文，且状态可以全局共享的对象，比如配置信息对象。
作用域（Scoped）： 作用域模式下，每个请求的生命周期内只会创建一个实例。
services.AddScoped<IProductRepository, ProductRepository>();
适合那些在一个请求处理过程中需要保持一致状态的对象，比如数据库上下文。
瞬态（Transient）： 瞬态模式下，每次请求都会创建一个新的实例。
services.AddTransient<IProductRepository, ProductRepository>();
适用于那些无状态的对象，每次使用都需要全新状态的情况。
解决方案： 根据对象的特性和使用场景，选择合适的生命周期。比如，如果一个对象需要在多个请求之间共享状态，就选择单例模式；如果只在一个请求内部使用，就选择作用域模式；如果每次使用都需要全新状态，就选择瞬态模式。
3. 循环依赖问题
循环依赖是指两个或多个类之间相互依赖，形成了一个闭环。比如 A 类依赖于 B 类，而 B 类又依赖于 A 类。
问题示例：
public class A
{
public A(B b)
{
// 构造函数注入 B
}
}
public class B
{
public B(A a)
{
// 构造函数注入 A
}
}
当尝试注入 A 或 B 时，就会陷入无限循环，最终导致栈溢出异常。
解决方案：
- 重构代码：重新设计类的结构，消除循环依赖。可以引入一个中间类来处理它们之间的交互。
- 使用属性注入：将依赖的注入方式从构造函数改为属性注入，这样可以在对象创建后再进行依赖的赋值。
public class A
{
public B B { get; set; }
}
public class B
{
public A A { get; set; }
}
4. 依赖注入性能问题
在高并发场景下，频繁创建和销毁对象可能会影响性能。特别是使用瞬态生命周期时，每次请求都会创建新的实例。
解决方案：
- 合理选择生命周期：尽量使用单例或作用域生命周期，减少对象的创建和销毁次数。
- 使用对象池：对于一些创建成本较高的对象，可以使用对象池来复用对象，提高性能。
四、应用场景
依赖注入在 .NET Core 中有很多应用场景。
1. 单元测试
在单元测试中，我们可以通过依赖注入来模拟依赖对象，从而独立测试目标类的功能。比如，我们可以使用 Moq 框架来创建 IProductRepository 的模拟对象，然后注入到 OrderService 中进行测试。
using Moq;
// 创建模拟对象
var mockProductRepository = new Mock<IProductRepository>();
mockProductRepository.Setup(repo => repo.GetProductName()).Returns("Mock Product");
// 创建 OrderService 实例并注入模拟对象
var orderService = new OrderService(mockProductRepository.Object);
// 调用方法进行测试
string result = orderService.CreateOrder();
2. 模块化开发
在大型项目中，我们可以将不同的功能模块进行独立开发，然后通过依赖注入将它们组合在一起。每个模块只需要定义好自己的接口和实现类，然后在主项目中进行注册和使用。
3. 配置管理
依赖注入可以方便地管理配置信息。我们可以将配置信息封装在一个配置类中，然后通过依赖注入将配置对象传递给需要使用的类。
// 配置类
public class AppConfig
{
public string ConnectionString { get; set; }
}
// 注册配置类
services.Configure<AppConfig>(Configuration.GetSection("AppConfig"));
// 在服务类中使用配置
public class MyService
{
private readonly AppConfig _appConfig;
public MyService(IOptions<AppConfig> appConfigOptions)
{
_appConfig = appConfigOptions.Value;
}
}
五、技术优缺点
优点
- 降低耦合度：通过依赖注入，各个组件之间的依赖关系从代码内部转移到外部，降低了代码的耦合度，提高了代码的可维护性和可测试性。
- 提高可测试性：在单元测试中，可以方便地使用模拟对象来替代真实的依赖对象，从而独立测试目标类的功能。
- 便于模块化开发：不同的功能模块可以独立开发，然后通过依赖注入进行组合，提高了开发效率。
缺点
- 增加代码复杂度：引入依赖注入会增加一些额外的代码，比如接口的定义、依赖的注册等，对于一些小型项目来说，可能会显得过于复杂。
- 性能开销：在高并发场景下，频繁创建和销毁对象可能会影响性能。
六、注意事项
- 正确配置依赖：确保所有的依赖都正确注册，并且选择合适的生命周期。
- 避免循环依赖：在设计类的结构时，要避免出现循环依赖的情况。
- 性能优化：在高并发场景下，要注意选择合适的生命周期，或者使用对象池等技术来提高性能。
七、文章总结
依赖注入是 .NET Core 中非常重要的一个特性，它可以帮助我们管理组件之间的依赖关系，提高代码的可维护性和可测试性。在使用依赖注入时，我们要注意正确配置依赖、合理选择生命周期、避免循环依赖等问题。同时，要根据具体的应用场景，充分发挥依赖注入的优势，提高开发效率和系统性能。
评论