通过两个整数键存储和检索值的最快方法答案

【问题标题】：Fastest way to store and retrieve value by two integer keys通过两个整数键存储和检索值的最快方法
【发布时间】：2013-03-16 12:15:47
【问题描述】：

我需要通过两个整数键快速存储和检索值。

所以我有输入值uint Id1, uint Id2，需要得到uint Count。

我还知道 Id1 和 Id2 的最大值（大约是 5 000 000）。

我当前的实现需要大约 70% 的应用程序工作时间，并且可能需要几天时间。

它只使用标准的 .net 字典，当然可以改进。但我想这是计算机科学中非常有用的操作，毫无疑问存在更有效的算法。

这是我的实现

void Main()
{
    var rep = new Repository();

    var sw = new Stopwatch();

    sw.Start();

    for (uint i = 0; i < 10000; i++)
    {
        for (uint j = 0; j < 1000; j++)
        {
            rep.Add(new DomainEntity(){Id1 = i, Id2 = j, Count = 1});
        }
    }

    for (uint i = 0; i < 10000; i++)
    {
        for (uint j = 0; j < 1000; j++)
        {
            rep.GetDomainEntityByIds(i,j);
        }
    }

    sw.Stop();
    Console.WriteLine ("Elapsed:{0}", sw.Elapsed);
}

public class Repository
{
        private readonly Dictionary<Tuple<UInt32, UInt32>, UInt32> _dictStore;

        public Repository()
        {
            _dictStore = new Dictionary<Tuple<uint, uint>, uint>();
        }

        public uint Add(DomainEntity item)
        {
            var entry = MapToTableEntry(item);
            _dictStore.Add(entry.Key,entry.Value);
            return 0;
        }

        public void Update(DomainEntity item)
        {
            var entry = MapToTableEntry(item);
            _dictStore[entry.Key] = entry.Value;
        }

        public IEnumerable<DomainEntity> GetAllItems()
        {
            return _dictStore.Select(MapToDomainEntity);
        }

        public DomainEntity GetDomainEntityByIds(uint articleId1, uint articleId2)
        {
            var tuple = new Tuple<uint, uint>(articleId1, articleId2);

            if (_dictStore.ContainsKey(tuple))
            {
                return MapToDomainEntity(new KeyValuePair<Tuple<uint, uint>, uint>(tuple, _dictStore[tuple]));
            }

            return null;
        }

        private KeyValuePair<Tuple<uint, uint>, uint> MapToTableEntry(DomainEntity item)
        {
            return new KeyValuePair<Tuple<uint, uint>, uint>(new Tuple<uint, uint>(item.Id1,item.Id2), item.Count);
        }

        private DomainEntity MapToDomainEntity(KeyValuePair<Tuple<uint, uint>, uint> entry)
        {
            return new DomainEntity
            {
                Id1 = entry.Key.Item1,
                Id2 = entry.Key.Item2,
                Count = entry.Value,
            };
        }
}

public class DomainEntity
{
        public uint Id1 { get; set; }
        public uint Id2 { get; set; }
        public uint Count { get; set; }
}

【问题讨论】：

直接使用 Dictionary,uint> 有什么问题？您每秒获得多少次查找操作，您希望获得多少？
另外，分析器说什么？你的瓶颈在哪里？
@Axarydax 我希望获得尽可能多的操作，因为在我当前的实现中，应用程序需要 DAYS 天来处理数据。它真的很慢。并且 70% 的时间都在 Repository 上。
@Axarydax 分析器在 Update 和 GetDomainEmtityByIds 方法中说这个问题。 GetDomainEmtityByIds 是最重的方法。
根据分析器，GetDomainEntityByIds() 会发生什么？ Tuple 的哈希计算是否花费最多时间？

标签： c# performance hashtable

【解决方案1】：

一个小的（？）改进，您可以使用TryGetValue 避免两次查找字典：

public DomainEntity GetDomainEntityByIds(uint articleId1, uint articleId2)
{
    var tuple = new Tuple<uint, uint>(articleId1, articleId2);
    uint value;
    if (_dictStore.TryGetValue(tuple, out value))
    {
        return MapToDomainEntity(new KeyValuePair<Tuple<uint, uint>, uint>(tuple, value));
    }

    return null;
}

【讨论】：

这是一个非常好的改进。在我的电脑上是 31 秒对 44 秒。
元组散列很差。你会遇到很多碰撞

【解决方案2】：

您要做的是使用高效的键和哈希创建高效的字典。由于字典始终使用 32 位值，并且您有大约 45 位数据，因此您无法创建唯一的哈希，但您应该尽力而为。

始终使用 TryGetValue() 而不是双重查找。
使用带有值类型键的字典时，请使用作为参数传递给字典构造函数的自定义 IEqualityComparer。
使用自定义哈希码尝试将子键中的最大信息量压缩到 32 位哈希中。

例子：

public class Storage 
{
   private Dictionary<Key, DomainObject> dict;

   public Storage()
   {
      dict = new Dictionary<Key, DomainObject>(Key.Comparer.Instance)
   }

   public DomainObject Get(uint a, uint b)
   {
      DomainObject obj;
      dict.TryGetValue(new Key(a,b), out obj);
      return obj;
   }

   internal struct Key 
   {
       internal readonly uint a;
       internal readonly uint b;

       public Key(uint a, uint b)
       {
          this.a = a;
          this.b = b;
       }     

       internal class Comparer : IEqualityComparer<Key>
       {
           internal static readonly Comparer Instance = new Comparer();
           private Comparer(){}

           public bool Equals(Key x, Key y)
           {  
               return x.a == y.a && x.b == y.b;
           }  

           public int GetHashCode(Key x)
           {    
              return (int)((x.a & 0xffff) << 16) | (x.b & 0xffff));
           }
       } 
   }  
}

【讨论】：

谢谢！我将 Tuple 更改为 Key，它提供了非常好的性能改进（31 秒对 2 秒）。我不明白 Tuple 有什么问题？
使用元组的主要问题是默认的元组是一个引用类型，所以每次创建键时都要分配一个引用对象。这里的键是一个纯值类型，并且足够小（64 位），将它作为值类型传递可能很有用。我的示例中的 Key 类型本质上是一个元组，但作为一个结构，并使用它自己的相等比较器来避免在字典中装箱。这可能是一个不值得的微优化，但我已经多次发现它值得。
我认为Tuple 最大的性能问题是GetHashCode 和Equals 方法中涉及的装箱问题。

【解决方案3】：

你在那里做了很多额外的工作，与KeyValuePair 相互转换。此外，DomainEntity 是一种引用类型，因此您可能应该只将引用存储在字典中，而不必每次查找时都从键和值创建它们。

将您的字典创建为：

var _dictStore = new Dictionary<Tuple<uint, uint>, DomainEntity>();

然后：

public uint Add(DomainEntity item)
{
    var key = new Tuple<uint, uint>(item.Id1, item.Id2);
    _dictStore.Add(key, item);
    return 0;
}

然后查找：

public DomainEntity GetDomainEntityByIds(uint articleId1, uint articleId2)
{
    var key = new Tuple<uint, uint>(articleId1, articleId2);
    DomainEntity value;
    if (!_dictStore.TryGetValue(key, out value))
    {
        value = null;
    }
    return value;
}

【讨论】：