ASP.NET Web API中缓存实现与依赖生命周期管控方案咨询

1. 缓存最佳实现方案 #

针对你的场景，推荐使用ASP.NET Core内置的IMemoryCache作为核心缓存组件，结合预加载和线程安全的实例创建逻辑，具体如下：

• 缓存键设计：将用户名与密码组合后生成唯一哈希值（如SHA256）作为缓存键，避免明文凭据暴露，同时确保每个凭据对对应唯一键。示例代码：

  private string GenerateCacheKey(string username, string password)
  {
      var combined = $"{username}:{password}";
      using var sha256 = SHA256.Create();
      var hashBytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(combined));
      return Convert.ToBase64String(hashBytes);
  }
  

• 预加载常用实例：通过IHostedService在应用启动时加载配置好的常用凭据列表，提前实例化依赖项并存入缓存。示例：

  public class PreloadCacheHostedService : IHostedService
  {
      private readonly IMemoryCache _cache;
      private readonly IConfiguration _config;
  
      public PreloadCacheHostedService(IMemoryCache cache, IConfiguration config)
      {
          _cache = cache;
          _config = config;
      }
  
      public async Task StartAsync(CancellationToken cancellationToken)
      {
          var commonCredentials = _config.GetSection("CommonCredentials").Get<List<Credential>>();
          foreach (var cred in commonCredentials)
          {
              var key = GenerateCacheKey(cred.Username, cred.Password);
              // 提前创建实例并存入缓存
              await _cache.GetOrCreateAsync(key, async entry =>
              {
                  entry.SlidingExpiration = TimeSpan.FromHours(2); // 滑动过期，长期未用自动回收
                  entry.PostEvictionCallbacks.Add(new PostEvictionCallbackRegistration
                  {
                      EvictionCallback = (key, value, reason, state) =>
                      {
                          // 实例回收时释放资源
                          if (value is IDisposable disposable)
                          {
                              disposable.Dispose();
                          }
                      }
                  });
                  return await CreateExpensiveDependencyAsync(cred.Username, cred.Password);
              });
          }
      }
  
      public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
  }
  

• 线程安全的实例获取：在业务逻辑中通过GetOrCreateAsync获取实例，确保同一凭据的实例只会被创建一次，避免并发场景下的重复初始化：

  var cacheKey = GenerateCacheKey(username, password);
  var dependency = await _cache.GetOrCreateAsync(cacheKey, async entry =>
  {
      entry.SlidingExpiration = TimeSpan.FromHours(1);
      return await CreateExpensiveDependencyAsync(username, password);
  });
  

2. DI管控缓存依赖项的生命周期 #

由于依赖项与凭据绑定且无法跨凭据复用，不能直接注册为单例/作用域实例，需通过工厂模式结合DI实现生命周期管控：

• 定义核心接口与实现：

  public interface IExpensiveDependency
  {
      Task DoBusinessAsync();
  }
  
  public class ExpensiveDependency : IExpensiveDependency, IDisposable
  {
      public ExpensiveDependency(string username, string password)
      {
          // 高成本初始化逻辑
      }
  
      public async Task DoBusinessAsync()
      {
          // 业务逻辑
      }
  
      public void Dispose()
      {
          // 释放资源
      }
  }
  

• 创建实例工厂：将工厂注册为单例（无状态，可全局复用），工厂内部封装缓存获取逻辑：

  public interface IExpensiveDependencyFactory
  {
      Task<IExpensiveDependency> GetOrCreateAsync(string username, string password);
  }
  
  public class ExpensiveDependencyFactory : IExpensiveDependencyFactory
  {
      private readonly IMemoryCache _cache;
  
      public ExpensiveDependencyFactory(IMemoryCache cache)
      {
          _cache = cache;
      }
  
      public async Task<IExpensiveDependency> GetOrCreateAsync(string username, string password)
      {
          var cacheKey = GenerateCacheKey(username, password);
          return await _cache.GetOrCreateAsync(cacheKey, async entry =>
          {
              entry.SlidingExpiration = TimeSpan.FromHours(1);
              entry.PostEvictionCallbacks.Add(new PostEvictionCallbackRegistration
              {
                  EvictionCallback = (key, value, reason, state) =>
                  {
                      if (value is IDisposable disposable)
                          disposable.Dispose();
                  }
              });
              return new ExpensiveDependency(username, password);
          });
      }
  
      private string GenerateCacheKey(string username, string password)
      {
          // 复用之前的哈希逻辑
          var combined = $"{username}:{password}";
          using var sha256 = SHA256.Create();
          var hashBytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(combined));
          return Convert.ToBase64String(hashBytes);
      }
  }
  

• DI容器注册：

  // Program.cs
  builder.Services.AddMemoryCache();
  builder.Services.AddHostedService<PreloadCacheHostedService>();
  builder.Services.AddSingleton<IExpensiveDependencyFactory, ExpensiveDependencyFactory>();
  

• 业务层使用：在控制器或业务类中注入工厂，按需获取实例：

  [ApiController]
  [Route("api/[controller]")]
  public class BusinessController : ControllerBase
  {
      private readonly IExpensiveDependencyFactory _factory;
  
      public BusinessController(IExpensiveDependencyFactory factory)
      {
          _factory = factory;
      }
  
      [HttpPost]
      public async Task<IActionResult> DoWork([FromBody] Credential cred)
      {
          var dependency = await _factory.GetOrCreateAsync(cred.Username, cred.Password);
          await dependency.DoBusinessAsync();
          return Ok();
      }
  }
  

特殊场景处理（非线程安全实例） #

如果依赖项实例本身非线程安全，不能被多个请求同时使用，可结合ObjectPool<T>优化：

1. 为每个凭据维护一个对象池，缓存的是池而非单个实例
2. 工厂从对应池获取实例，业务逻辑完成后归还到池中
3. 池自动管理实例的创建与回收，既复用实例降低启动成本，又保证线程安全

内容的提问来源于stack exchange，提问作者Jeppe