ASP.NET Core接口与服务资源管理优化的困惑

核心问题拆解 #

你遇到的是典型的对象创建逻辑复用与职责划分的矛盾：直接在Controller实例化对象会导致频繁的对象创建开销，单服务类方案又因整合过多逻辑违反单一职责原则，进而变得臃肿难维护。

具体优化方案 #

1. 工厂模式+依赖注入拆分职责 #

这是最直接的解决方案，将对象创建逻辑从Controller或臃肿的服务类中剥离：

• 定义抽象工厂接口，仅负责产品对象的创建：

  public interface IProductFactory
  {
      IProduct CreateRedProduct();
      IProduct CreateBlueProduct();
  }
  

• 实现工厂类，迁移原有的产品创建逻辑：

  public class ProductFactory : IProductFactory
  {
      public IProduct CreateRedProduct()
      {
          return new MakeRedProduct();
      }
  
      public IProduct CreateBlueProduct()
      {
          return new MakeBlueProduct();
      }
  }
  

• 在Program.cs中将工厂注册为单例（工厂本身无状态，单例复用无风险）：

  builder.Services.AddSingleton<IProductFactory, ProductFactory>();
  

• Controller中注入工厂，通过工厂获取产品实例：

  [ApiController]
  [Route("api/products")]
  public class ProductsController : ControllerBase
  {
      private readonly IProductFactory _productFactory;
  
      public ProductsController(IProductFactory productFactory)
      {
          _productFactory = productFactory;
      }
  
      [HttpGet("red")]
      public IActionResult GetRedProduct()
      {
          var product = _productFactory.CreateRedProduct();
          // 处理产品业务逻辑
          return Ok(product);
      }
  }
  

2. 按产品类型拆分工厂（应对产品类型持续增长） #

如果后续产品类型不断增加，单一工厂类也会变得臃肿，可进一步拆分为细分产品工厂：

• 定义针对单一产品的工厂接口：

  public interface IRedProductFactory
  {
      IProduct Create();
  }
  
  public interface IBlueProductFactory
  {
      IProduct Create();
  }
  

• 实现各自的工厂类：

  public class RedProductFactory : IRedProductFactory
  {
      public IProduct Create() => new MakeRedProduct();
  }
  
  public class BlueProductFactory : IBlueProductFactory
  {
      public IProduct Create() => new MakeBlueProduct();
  }
  

• 注册时均设为单例：

  builder.Services.AddSingleton<IRedProductFactory, RedProductFactory>();
  builder.Services.AddSingleton<IBlueProductFactory, BlueProductFactory>();
  

• Controller按需注入对应工厂，职责划分更清晰。

3. 对象池优化高频创建场景 #

如果MakeRedProduct/MakeBlueProduct是无状态或可重置状态的对象，且请求量极大，可以用ASP.NET Core内置的ObjectPool减少对象创建与销毁的开销：

• 注册对象池：

  builder.Services.AddSingleton<ObjectPoolProvider, DefaultObjectPoolProvider>();
  builder.Services.AddSingleton(sp =>
  {
      var provider = sp.GetRequiredService<ObjectPoolProvider>();
      return provider.Create<MakeRedProduct>(new DefaultPooledPolicy<MakeRedProduct>());
  });
  

• 通过对象池获取、重置、归还对象：

  public class RedProductFactory : IRedProductFactory
  {
      private readonly ObjectPool<MakeRedProduct> _pool;
  
      public RedProductFactory(ObjectPool<MakeRedProduct> pool)
      {
          _pool = pool;
      }
  
      public IProduct Create()
      {
          var product = _pool.Get();
          // 重置产品状态（如果有需要）
          product.Reset();
          return product;
      }
  
      // 产品使用完毕后归还到池内
      public void Return(MakeRedProduct product)
      {
          _pool.Return(product);
      }
  }
  

关键原则总结 #

• 遵循单一职责原则：每个类只负责一件事（工厂仅处理对象创建，服务类仅处理业务逻辑）
• 利用依赖注入管理对象生命周期：无状态的工厂/服务用单例，有状态对象按需创建或用对象池复用
• 避免过度设计：先从单一工厂模式开始，当产品类型超过5-6种时再考虑拆分细分工厂

内容的提问来源于stack exchange，提问作者Felipe La Rotta