在 C# 中，是否有开箱即用的方法来构建 3 路查找表？

Question

我有一个内存中的“表”，可能看起来像这样：

Favorite#  Name        Profession
---------  ----------  ------------------
3          Names.Adam  Profession.Baker
9          Names.Bob   Profession.Teacher
7          Names.Carl  Profession.Coder
7          Names.Dave  Profession.Miner
5          Names.Fred  Profession.Teacher

我想要做的是使用 3 个字段中的任何一个进行快速有效的查找。 换句话说，我想要：

• myTable[3] 和 myTable[Names.Adam] 和 myTable[Professions.Baker] 全部返回 < code>{3,Names.Adam,Profession.Baker}
• myTable[Profession.Teacher] 返回两个 {9,Names.Bob,Profession.Teacher} 和 {5,Names.Fred,Profession.Teacher}。

该表是在运行时根据用户的操作构建的，并且不能存储在数据库中，因为它用在无法保证数据库连接的部分中。

现在，我“简单地”（哈！）使用 3 个 uber-Dictionaries 存储它，每个 uber-Dictionaries 使用其中一列（FavoriteNumber、Name、Profession）进行键控，并且 uber-Dictionaries 中的每个值都包含 2 个字典，这些字典本身是键控的其余各列（因此“Name”超级词典中的值的类型为 Dictionary 和 Dictionary）

这需要在 2 个字典中进行 2 次查找，并再次遍历一个数组（通常包含 1 或 2 个元素）。

任何人都可以提出更好的方法来执行此操作，因为该表我不介意花费额外的内存？可能很小（不超过 20 个条目），但我愿意牺牲一点 CPU 来使其代码更容易维护......

Answer 1

但实际上并不是使用字典，但如果您创建这样的类集合，

class Person {
    public int FavoriteNumber;
    public string Name;
    public string Profession;
}

则可以使用 LINQ 来搜索该集合。

IList<Person> people = /* my collection */;
var selectedPeople = people.Where(p => p.FavoriteNumber = 3);
var selectedPeople2 = people.Where(p => p.Name == "Bob");
var selectedPeople3 = people.Where(p => p.Profession = "Teacher");

或者，如果您更喜欢普通的 LINQ 语法，

var selectedPeople4 = from p in people
                      where p.Name == "Bob"
                      select p;

这些 selectedPeople 变量中的每一个都将被键入为 IEnumerable，您可以使用循环来搜索它们。

Answer 2

对于 20 行，只需使用 线性扫描 - 它将在各个方面都是最有效的。

对于较大的套装； hzere 是一种使用 LINQ 的 ToLookup 和延迟索引的方法：

public enum Profession {
    Baker, Teacher, Coder, Miner
}
public class Record {
    public int FavoriteNumber {get;set;}
    public string Name {get;set;}
    public Profession Profession {get;set;}
}
class Table : Collection<Record>
{
    protected void Rebuild()
    {
        indexName = null;
        indexNumber = null;
        indexProfession = null;
    }
    protected override void ClearItems()
    {
        base.ClearItems();
        Rebuild();
    }
    protected override void InsertItem(int index, Record item)
    {
        base.InsertItem(index, item);
        Rebuild();
    }
    protected override void RemoveItem(int index)
    {
        base.RemoveItem(index);
        Rebuild();
    }
    protected override void SetItem(int index, Record item)
    {
        base.SetItem(index, item);
        Rebuild();
    }
    ILookup<int, Record> indexNumber;
    ILookup<string, Record> indexName;
    ILookup<Profession, Record> indexProfession;
    protected ILookup<int, Record> IndexNumber {
        get {
            if (indexNumber == null) indexNumber = this.ToLookup(x=>x.FavoriteNumber);
            return indexNumber;
        }
    }
    protected ILookup<string, Record> IndexName {
        get {
            if (indexName == null) indexName = this.ToLookup(x=>x.Name);
            return indexName;
        }
    }
    protected ILookup<Profession, Record> IndexProfession {
        get {
            if (indexProfession == null) indexProfession = this.ToLookup(x=>x.Profession);
            return indexProfession;
        }
    }
    public IEnumerable<Record> Find(int favoriteNumber) { return IndexNumber[favoriteNumber]; }
    public IEnumerable<Record> Find(string name) { return IndexName[name]; }
    public IEnumerable<Record> Find(Profession profession) { return IndexProfession[profession]; }
}

Answer 3

我认为执行此操作的方法是编写自己的对象，其中

public ICollection<Record> this[int] { get; }
public ICollection<Record> this[Profession] { get; }
public ICollection<Record> this[Names] { get; }

record 是保存元素的类。

在内部，您保留一个列表，每个索引器执行 List.FindAll() 来获取您需要的内容。

Answer 4

没有任何开箱即用的东西（可能除了数据表）。 不过，它可以通过比您所拥有的更简单的方式来完成：

创建一个类来保存数据：

class PersonData {
   public int FavoriteNumber;
   public string Name;
   public string Profession;
}

然后保留 3 个指向同一引用的字典：

PersonData personData = new PersonData();
Dictionary<int, PersonData> ...;
Dictionary<string, PersonData> ...;
Dictionary<string, PersonData> ...;

我建议将所有这些封装到一个外观类中隐藏实现细节。

Answer 5

您可以使用 sqlite 数据库作为支持吗？ 使用 sqlite，您甚至可以选择构建内存数据库。