给定一个通用列表，我需要某种索引(在数据库意义上)，以允许我快速检索。这个索引的键不是唯一的，所以我不能使用字典。这是我的想法:给定一个类 Foo { P1, P2, P3 } 可能有这样的数据

{ "aaa", 111, "yes" }
{ "aaa", 112, "no" }
{ "bbb", 111, "no" }
{ "bbb", 220, "yes" }
{ "bbb", 220, "no" }
{ "ccc", 300, "yes" }

我需要快速访问 P1 为“bbb”(第 3、4 和 5)的所有记录或 P2 为 111(第 1 和 3)的所有记录。我可以使用排序列表，但如果我需要不止一种排序/索引方式，我最终会得到重复的列表。

.NET 框架中是否有内置的东西，或者可能是一个操作系统库可以做这样的事情？谢谢。

附言我提到“排序列表”的想法是排序列表将更快地返回/查找项目。我不需要必须对列表进行排序；我只是在寻找快速检索/查找。

最佳答案

永远不要忘记这个原则:正确、清晰、简洁、快速。以该顺序。所以，首先编写简单的实现代码:

static IEnumerable<T> GetByIndex<T>(
    List<T> list,
    Func<T, TIndex> func,
    TIndex key
) {
    return list.Where(x => func(x) == key);
}

用法:

List<Test> tests = new List<Test>() {
            new Test { Name = "aaa", Value = 111, Valid = Valid.Yes },
            new Test { Name = "aaa", Value = 111, Valid = Valid.Yes },
            new Test { Name = "bbb", Value = 112, Valid = Valid.No },
            new Test { Name = "bbb", Value = 111, Valid = Valid.No },
            new Test { Name = "bbb", Value = 220, Valid = Valid.No },
            new Test { Name = "ccc", Value = 220, Valid = Valid.Yes }
};
IEnumerable<Test> lookup = GetByIndex(tests, x => x.Name, "bbb");

以上正确、清晰、简洁。几乎可以肯定它的速度足以满足您的目的。

因此，就使其变快而言，您必须首先测量:

1. 制定合理的绩效标准。
2. 建立真实世界数据的试验台。
3. 根据真实世界数据的测试台分析简单方法。请注意，分析包括推断此功能是否是您应用程序中的瓶颈。

然后，当且仅当这对您来说不够快时，您才应该尝试优化。实现 IndexedList<T> : ICollection<T> 并不难这将使您能够索引各种属性。

这是一个可以帮助您入门的简单实现:

class IndexedList<T> : IEnumerable<T> {
    List<T> _list;
    Dictionary<string, Dictionary<object, List<T>>> _dictionary;
    Dictionary<string, Func<T, object>> _propertyDictionary;

    public IndexedList(IEnumerable<string> propertyNames) : this(propertyNames, new List<T>()) { }

    public IndexedList(IEnumerable<string> propertyNames, IEnumerable<T> source) {
        _list = new List<T>();
        _dictionary = new Dictionary<string, Dictionary<object, List<T>>>();
        _propertyDictionary = BuildPropertyDictionary(propertyNames);
        foreach (var item in source) {
            Add(item);
        }
    }

    static Dictionary<string, Func<T, object>> BuildPropertyDictionary(IEnumerable<string> keys) {
        var propertyDictionary = new Dictionary<string,Func<T,object>>();
        foreach (string key in keys) {
            ParameterExpression parameter = Expression.Parameter(typeof(T), "parameter");
            Expression property = Expression.Property(parameter, key);
            Expression converted = Expression.Convert(property, typeof(object));
            Func<T, object> func = Expression.Lambda<Func<T, object>>(converted, parameter).Compile();
            propertyDictionary.Add(key, func);
        }
        return propertyDictionary;
    }

    public void Add(T item) {
        _list.Add(item);
        foreach (var kvp in _propertyDictionary) {
            object key = kvp.Value(item);
            Dictionary<object, List<T>> propertyIndex;
            if (!_dictionary.TryGetValue(kvp.Key, out propertyIndex)) {
                propertyIndex = new Dictionary<object, List<T>>();
                _dictionary.Add(kvp.Key, propertyIndex);
            }
            List<T> list;
            if (!propertyIndex.TryGetValue(key, out list)) {
                list = new List<T>();
                propertyIndex.Add(key, list);
            }
            propertyIndex[key].Add(item);
        }
    }

    public IEnumerable<T> GetByIndex<TIndex>(string propertyName, TIndex index) {
        return _dictionary[propertyName][index];
    }

    public IEnumerator<T> GetEnumerator() {
        return _list.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator() {
        return GetEnumerator();
    }
}

用法:

List<Test> tests = new List<Test>() {
            new Test { Name = "aaa", Value = 111, Valid = Valid.Yes },
            new Test { Name = "aaa", Value = 111, Valid = Valid.Yes },
            new Test { Name = "bbb", Value = 112, Valid = Valid.No },
            new Test { Name = "bbb", Value = 111, Valid = Valid.No },
            new Test { Name = "bbb", Value = 220, Valid = Valid.No },
            new Test { Name = "ccc", Value = 220, Valid = Valid.Yes }
};
// build an IndexedList<Text> indexed by Name and Value
IndexedList<Test> indexed = new IndexedList<Test>(new List<string>() { "Name", "Value" }, tests);
// lookup where Name == "bbb"
foreach (var result in indexed.GetByIndex("Name", "bbb")) {
    Console.WriteLine(result.Value);
}

但是你看，除非简单的实现不够快，否则你不这样做的原因是你刚刚添加到系统中的额外复杂性。您只是添加了要维护的新代码和要测试的新代码，如果这对您的实际数据没有更快的速度或者不是您的应用程序的瓶颈，则可能不会有任何收获。

关于c# - 具有多个索引的列表，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/2143773/