按属性搜索的最快 C# 集合

Question

我有以下简单的类：

public class MyClass{
    public long StartRange { get; set; }
    public long EndRange { get; set; }
    public int Id { get; set; }
}

我需要在内存缓存中存储很多，10^5 到 10^6。在应用程序启动时将对该缓存进行一次写入和多次读取。这个缓存会在一个 ASP.NET 环境中被访问，所以线程很多。

我需要在此缓存中查找我的值介于 StartRange 和 EndRange 之间的行。范围不重叠，但可能是稀疏的。我发现执行此操作的最简单方法如下：

public MyClass Lookup(long value){
    return _set.FirstOrDefault(d => value >= d.StartRange && value <= d.EndRange);
}

我已经尝试过将集合存储为IOrderedEnumerable<T> 和SortedSet<T>。 SortedSet 快了一个数量级。 HashSet<T> 比 SortedSet 稍微快一点。任何关于使用最有效的集合类或更好的查找的建议将不胜感激。

Answer 1

范围不重叠，但可能是稀疏的。

如果我理解正确，这意味着如果你按 StartRange 对它们进行排序，然后用value >= d.StartRange 标识第一个项目，你可以立即知道你找到了你的项目（如果value <= d.EndRange），或者没有匹配，对吧？

因此，您只需这样做就可以将时间减半：

public MyClass Lookup(long value){
    var candidate = _set.FirstOrDefault(d => value >= d.StartRange);
    if(candidate != null && value <= candidate.EndRange)
    {
        return candidate;
    }
    return null;
}

而且，由于在已排序的集合中搜索可以在O(log n) 时间内轻松完成，因此您应该能够通过二分搜索获得显着的性能提升。下面是一些示例代码，可以帮助您走上正轨。

List<MyClass> _set = new[]{
   new MyClass{StartRange = 18, EndRange = 18},
    new MyClass{StartRange = 10, EndRange = 15},
     new MyClass{StartRange = 20, EndRange = 21}
}.OrderBy(m => m.StartRange).ToList();

public class StartRangeComparer : IComparer<MyClass>
{
    public int Compare(MyClass first, MyClass second)
    {
        return first.StartRange.CompareTo(second.StartRange);
    }
}

StartRangeComparer startRangeComparer = new StartRangeComparer();

public MyClass Lookup(long value){
    var index = _set.BinarySearch(new MyClass{StartRange = value}, startRangeComparer);
    int candidateIndex = index >= 0 ? index : (~index) - 1;
    if(candidateIndex < 0)
    {
        // the given value is before any start-ranges in the list
        return null;
    }
    MyClass candidate = _set[candidateIndex];
    if(candidate.EndRange >= value)
    {
        return candidate;
    }
    else
    {
        return null;
    };
}

Answer 2

你能不能只按StartRange 排序，使用Array.BinarySearch 来找到最近的一个（仍然更小），因为你的范围很稀疏，通过一次检查就知道（如果Endrange 大于x）如果你找到了还是错过了？
你所要做的就是实现IComparable<T> 和StartRange 作为键，这很容易。

Answer 3

可能不是您真正需要的，但您研究过 NoSQL 吗？ 有些实现就像你想要的那样，有些有一个可以从内存中运行的缓存，所以应该很快。

如果我没记错的话，Redis 可能是您想要研究的那个。 （这是关于 Redis 的 article）。

K，对我的东西进行了一些挖掘：NoSQL DB comparisson，你可以看到有哪些主要风格以及它们适用于哪些用例。

据我所知，他们在一些实现中使用 B-Trees 来提高速度。如果你想重新创建轮子，我猜你可能想做类似的事情。

Answer 4

如果您的范围现在或将来可能重叠，您可以考虑使用interval tree。

但是，如果您确实确定您的范围没有重叠，请将您的 class 更改为 struct 并执行以下操作。将class 改为struct 的原因有两个：

• 使用数组节省内存。引用类型数组是堆上各个对象的引用数组。

• 可能更重要的是，它有助于保持参考的局部性。您将在一个连续的内存块中跳跃，而不是在整个堆中随机跳跃。这应该有助于减少分页。

代码如下：

class MyClassMap
{
    MyClass[] backingStore ; // ordered by StartRange, then EndRange

    public MyClassMap( IEnumerable<MyClass> source )
    {
        backingStore.OrderBy( x => x.StartRange ).ThenBy( x => x.EndRange ) ;
    }

    public int? GetIdFromValue( long value )
    {
        int  lo = 0 ;
        int  hi = backingStore.Length ;
        int? ix = null ;
        while ( lo <= hi && !ix.HasValue )
        {
            int mid = lo + ((hi-lo)>>1) ;
            MyClass current = backingStore[mid] ;
            if      ( value > current.EndRange   ) { lo = mid+1      ; }
            else if ( value < current.StartRange ) { hi = mid-1      ; }
            else                                   { ix = current.Id ; }
        }

        return ix ;

    }

}