基于双字段查询的DB实体缓存查询性能优化问询

嘿，这个问题我太熟了——你现在用List做线性查找，数据量上去之后肯定会慢，尤其是每次都要遍历整个集合做双字段比对。给你几个实用的优化方案，都是.NET里现成的工具，不用自己造轮子：

.NET里没有直接的“双字段键”集合，但你可以用复合键来实现，两种方式任选：

• 方案一：自定义不可变键类（兼容性好，适合所有.NET版本）
  写一个轻量的结构体作为键，重写哈希和相等判断逻辑，确保能被Dictionary正确识别：

  public readonly struct TenantKey : IEquatable<TenantKey>
  {
      public string FriendlyName { get; }
      public int GroupId { get; }
  
      public TenantKey(string friendlyName, int groupId)
      {
          FriendlyName = friendlyName;
          GroupId = groupId;
      }
  
      public bool Equals(TenantKey other)
      {
          return FriendlyName == other.FriendlyName && GroupId == other.GroupId;
      }
  
      public override bool Equals(object obj)
      {
          return obj is TenantKey other && Equals(other);
      }
  
      public override int GetHashCode()
      {
          // 组合两个字段的哈希值，尽量减少冲突
          return HashCode.Combine(FriendlyName, GroupId);
      }
  }
  

  然后把原来的List<tenant>换成Dictionary<TenantKey, tenant>，初始化和查询逻辑改成这样：

  private Dictionary<TenantKey, tenant> _tenantCache = new Dictionary<TenantKey, tenant>();
  
  public override void ReadFromDB()
  {
      using (var ctx = new MyContext())
      {
          _tenantCache = ctx.tenants.ToDictionary(t => new TenantKey(t.friendlyName, t.groupId));
      }
  }
  
  public tenant LookupByFNandGID(string fn, int groupId)
  {
      _tenantCache.TryGetValue(new TenantKey(fn, groupId), out var match);
      return match;
  }
  

• 方案二：用ValueTuple作为键（.NET Core 2.0+/NET Framework 4.7.2+支持）
  不用写自定义类，直接用C#的元组类型当键，代码更简洁：

  private Dictionary<(string FriendlyName, int GroupId), tenant> _tenantCache;
  
  // 初始化缓存
  public override void ReadFromDB()
  {
      using (var ctx = new MyContext())
      {
          _tenantCache = ctx.tenants.ToDictionary(t => (t.friendlyName, t.groupId));
      }
  }
  
  // 查询方法
  public tenant LookupByFNandGID(string fn, int groupId)
  {
      _tenantCache.TryGetValue((fn, groupId), out var match);
      return match;
  }
  

  这两种方案的查询时间复杂度都是O(1)，比原来的*O(n)*线性查找快太多，数据量越大，性能提升越明显。

如果你的业务里经常需要按groupId过滤查询，还可以做个二级缓存：用Dictionary<int, Dictionary<string, tenant>>，第一层按groupId分组，第二层按friendlyName映射：

private Dictionary<int, Dictionary<string, tenant>> _groupedTenantCache;

public override void ReadFromDB()
{
    using (var ctx = new MyContext())
    {
        _groupedTenantCache = ctx.tenants
            .GroupBy(t => t.groupId)
            .ToDictionary(
                group => group.Key,
                group => group.ToDictionary(t => t.friendlyName)
            );
    }
}

public tenant LookupByFNandGID(string fn, int groupId)
{
    if (_groupedTenantCache.TryGetValue(groupId, out var groupTenants))
    {
        groupTenants.TryGetValue(fn, out var match);
        return match;
    }
    return null;
}

这种方式同样是*O(1)*的查询效率，而且后续如果有按groupId批量获取租户的需求，也更灵活。

如果暂时不想改集合类型，至少可以用LINQ的FirstOrDefault代替手动遍历，但本质还是线性查找（O(n)），性能提升不大：

public tenant LookupByFNandGID(string fn, int groupId)
{
    return list.FirstOrDefault(t => t.friendlyName == fn && t.groupId == groupId);
}

总结 #

优先选ValueTuple或自定义复合键的Dictionary，这是.NET里最适合双字段快速查找的方案，代码改动小，性能提升显著，完全解决你当前的性能瓶颈。

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