如果值是对象并且这些对象的属性是键，是否有比字典更好的数据结构？

Question

我有一个 Dictionary ，其中 int 是 obj 的属性。有没有更好的数据结构呢？我觉得使用属性作为钥匙是多余的。

此 Dictionary 是容器类中的一个字段，允许根据 int id 数字对 obj 值进行随机索引。容器类中的简化（无异常处理）索引器如下所示：

obj this[int id]
{
     get{ return this.myDictionary[id];}
}

其中 myDictionary 是前面提到的保存对象的 Dictionary。

这可能是快速随机访问的典型方式，但我想获得第二意见。

Answer 1

框架中没有具体的类可以执行此操作。不过有一个抽象的，KeyedCollection。您必须从该类派生您自己的类并实现 GetKeyForItem() 方法。这非常简单，只需返回您想要索引的属性的值即可。

这就是您需要做的全部，但请密切关注 ChangeItemKey()。当用作键的属性更改值时，您必须执行一些有意义的操作。如果您确保该属性是不可变的（只有一个 getter），那么就很容易了。但如果你不这样做，那就很尴尬了，对象本身现在需要知道它存储在你的集合中。如果您不采取任何措施（调用 ChangeItemKey），该对象就会在集合中丢失，您将无法找回它。非常接近泄漏。

请注意 Dictionary<> 是如何显示的通过分别指定键值和对象来回避这个问题。您可能仍然无法找回该对象，但至少它不会因设计而丢失。

Answer 2

有一个 KeyedCollection 类。

编辑：KeyedCollection 可以在内部使用字典，但对于这种特定场景，它的界面比原始字典更干净，因为您可以直接按值查找。诚然，我觉得它总体上不是很有用。

Answer 3

如果工厂设置带来的额外开销不值得，您可以轻松实现自己的 KeyedCollection。 System.Collections.ObjectModel 中的原始 KeyedCollection 内部是一个 Dictionary 和一个 List code> 这意味着您可以在 IList<> 和 IDictionary<> 上定义操作。例如，您可以插入、按索引访问、按插入顺序遍历集合（所有这些 IList<> 都很方便），同时您可以基于键进行快速查找（借助字典）。这意味着，当您添加或删除项目时，除了保存额外的 List 所需的少量内存开销之外，还必须在两个基础集合上执行这些项目（但对象不会重复）像这样）。虽然添加速度不会受到太大影响（List>> 添加是 O(1)），删除速度受到一点影响。

如果你不关心插入顺序和按索引访问：

public class KeyedCollection<TKey, TItem> : ICollection<TItem>
{
    MemberInfo _keyInfo;
    Func<TItem, TKey> _keySelector;
    Dictionary<TKey, TItem> _dict;

    public TItem this[TKey key]
    {
        get { return _dict[key]; }
    }

    public int Count
    {
        get { return _dict.Count; }
    }

    public bool IsReadOnly
    {
        get { return false; }
    }

    public ICollection<TKey> Keys
    {
        get { return _dict.Keys; }
    }

    private ICollection<TItem> Items
    {
        get { return _dict.Values; }
    }

    public KeyedCollection(Expression<Func<TItem, TKey>> keySelector, IEqualityComparer<TKey> comparer = null)
    {
        var keyExpression = keySelector.Body as MemberExpression;
        if (keyExpression != null)
            _keyInfo = keyExpression.Member;

        _keySelector = keySelector.Compile();
        _dict = new Dictionary<TKey, TItem>(comparer);
    }



    private TKey GetKeyForItem(TItem item)
    {
        return _keySelector(item);
    }

    public bool ContainsKey(TKey key)
    {
        return _dict.ContainsKey(key);
    }

    public bool Contains(TItem item)
    {
        return ContainsKey(GetKeyForItem(item));
    }

    public bool TryGetItem(TKey key, out TItem item)
    {
        return _dict.TryGetValue(key, out item);
    }

    public void Add(TItem item)
    {
        _dict.Add(GetKeyForItem(item), item);
    }

    public void AddOrUpdate(TItem item)
    {
        _dict[GetKeyForItem(item)] = item;
    }

    public bool UpdateKey(TKey oldKey, TKey newKey)
    {
        TItem oldItem;
        if (_keyInfo == null || !TryGetItem(oldKey, out oldItem) || !SetItem(oldItem, newKey))   // important
            return false;

        RemoveKey(oldKey);
        Add(oldItem);
        return true;
    }

    private bool SetItem(TItem item, TKey key)
    {
        var propertyInfo = _keyInfo as PropertyInfo;
        if (propertyInfo != null)
        {
            if (!propertyInfo.CanWrite)
                return false;

            propertyInfo.SetValue(item, key, null);
            return true;
        }

        var fieldInfo = _keyInfo as FieldInfo;
        if (fieldInfo != null)
        {
            if (fieldInfo.IsInitOnly)
                return false;

            fieldInfo.SetValue(item, key);
            return true;
        }

        return false;
    }

    public bool RemoveKey(TKey key)
    {
        return _dict.Remove(key);
    }

    public bool Remove(TItem item)
    {
        return RemoveKey(GetKeyForItem(item));
    }

    public void Clear()
    {
        _dict.Clear();
    }

    public void CopyTo(TItem[] array, int arrayIndex)
    {
        Items.CopyTo(array, arrayIndex);
    }

    public IEnumerator<TItem> GetEnumerator()
    {
        return Items.GetEnumerator();
    }

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

我已经实现了ICollection 使其更加符合标准 - 并且您还可以获得很好的集合初始值设定项语法！ :)

示例用法：

var p1 = new Person { Name = "a" };
var p2 = new Person { Name = "b" };

var people = new KeyedCollection<string, Person>(p => p.Name) { p1, p2 };
// p1 == people["a"];
// p2 == people["b"];

Answer 4

C# 动态属性 帖子似乎表明使用字典是一种流行的选择。其他帖子建议使用 HashTable

字典与哈希表