2

我有一个充当字典的 C# 类，所以我现在正在支持 IDictionary。

一切都很好，除了属性键和值：

ICollection<TKey> Keys { get; }
ICollection<TValue> Values { get; }

我在内部没有键或值的集合，所以我想知道如何将这些作为 ICollection 提供。

我的第一次尝试是像这样使用“收益回报”的魔力：

ICollection<TValue> Values { 
    get {
        for( int i = 0; i < nbValues; ++i ) {
            yield return GetValue(i);
        }
    }
}

但当然这不起作用，因为返回的类型不是 IEnumerator 而是 ICollection ...

这太糟糕了，因为这将是最简单的解决方案！

我的第二次尝试是将我的值复制到一个新创建的数组中并返回该数组。 

ICollection<TValue> Values { 
    get {
        TValue[] copy = new TValue[nbValues];
        for( int i = 0; i < nbValues; ++i ) {
            copy[i] = GetValue(i);
        }
        return copy;
    }
}

这会起作用，因为 Array 支持 ICollection。
但问题是 ICollection 具有添加和删除条目的方法。如果调用者调用这些方法，则只会修改副本而不是字典...

我选择的最终解决方案是让我的字典支持 IDictionary 以及 ICollection 和 ICollection，这样我就可以从属性 Keys 和 Values 中返回这些集合......

public class MyDictionary : IDictionary<TKey,TValue>, 
                            ICollection<TKey>, 
                            ICollection<TValue>
{
}

所以现在属性 Keys 和 Values 的 get 访问器只返回“this”，即：字典。

ICollection<TValue> Values { 
    get {
        return this;
    }
}

这可能是最理想的解决方案，但我发现无论何时要实现 IDictionary，都必须实现两个额外的接口很麻烦。

你有什么别的想法吗？

我在想也许将副本作为数组返回毕竟不是一个坏主意。无论如何，IDictionary 中已经有一个 Add 和 Remove 方法，使用起来更有意义。

也许返回包装数组的 ReadOnlyCollection 会更好，因为任何修改返回的集合的尝试都会失败？

ICollection<TValue> Values { 
    get {
        TValue[] copy = new TValue[nbValues];
        for( int i = 0; i < nbValues; ++i ) {
            copy[i] = GetValue(i);
        }
        return new System.Collections.ObjectModel.ReadOnlyCollection<TValue>(copy);
    }
}
4

3 回答 3

2

我个人不希望您能够通过无论如何从字典中删除键和值Keys-Values我认为不这样做很好。

返回 aReadOnlyCollection<T>很好 - 如果调用者尝试修改集合，那么调用者只会得到一个异常，而不是只是默默地忽略该尝试。

顺便说一句，该异常遵循以下行为Dictionary<TKey, TValue>：

using System;
using System.Collections.Generic;

class Test
{
    static void Main()
    {
        IDictionary<string, string> dictionary = 
            new Dictionary<string, string> {{ "a", "b" }};
        dictionary.Keys.Clear();
        Console.WriteLine(dictionary.Count);
    }
}

结果：

Unhandled Exception: System.NotSupportedException: Mutating a key collection
derived from a dictionary is not allowed.
   at System.Collections.Generic.Dictionary`2
            .KeyCollection.System.Collections.Generic.ICollection<TKey>.Clear()
   at Test.Main()

正如 SLaks 所说，如果您可以创建自己的ICollection<T>惰性实现，那会更好 - 但如果由于某种原因这很棘手，或者确实在您的情况下性能并不重要，只需创建数组并将其包装在ReadOnlyCollection<T>很好。不过，您应该考虑以任何一种方式记录预期的性能。

如果您确实创建了自己的惰性实现，请注意一件事：您可能应该有某种“版本号”，以确保在基础数据发生更改时使返回的集合无效。

于 2013-02-07T16:26:08.370 回答
1

AReadOnlyCollection是您列出的选项中的最佳方法；这些集合不应该是可写的。

但是，您的吸气剂是 O(n)，这不好。

正确的方法是创建自己的集合类来实现ICollection<T>并返回字典的实时视图。（并从突变方法中抛出异常）

这是采取的方法Dictionary<TKey, TValue>；它确保属性获取器快速，并且不会浪费额外的内存。

于 2013-02-07T16:25:01.283 回答
0

谢谢大家的答案。

所以我最终做了两个实用程序类，它们实现了 Keys 和 Values 属性请求的两个 ICollection。我有一些字典需要添加对 IDictionary 的支持，因此我将重复使用它们几次：

这是键集合的类：

public class ReadOnlyKeyCollectionFromDictionary< TDictionary, TKey, TValue >
                       : ICollection<TKey>
                       where TDictionary : IDictionary<TKey,TValue>, IEnumerable<TKey>
{
    IDictionary<TKey, TValue> dictionary;

    public ReadOnlyKeyCollectionFromDictionary(TDictionary inDictionary)
    {
        dictionary = inDictionary;
    }

    public bool IsReadOnly {
        get { return true; }
    }

    Here I implement ICollection<TKey> by simply calling the corresponding method on 
    the member "dictionary" but I throw a NotSupportedException for the methods Add,
    Remove and Clear

    public IEnumerator<TKey> GetEnumerator()
    {
        return (dictionary as IEnumerable<TKey>).GetEnumerator();
    }

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

这是值集合的类：

public class ReadOnlyValueCollectionFromDictionary<TDictionary, TKey, TValue> 
                       : ICollection<TValue>
                       where TDictionary : IDictionary<TKey, TValue>, IEnumerable<TValue>
{
    IDictionary<TKey, TValue> dictionary;

    public ReadOnlyValueCollectionFromDictionary(TDictionary inDictionary)
    {
        dictionary = inDictionary;
    }

    public bool IsReadOnly {
        get { return true; }
    }

    Here I implement ICollection<TValue> by simply calling the corresponding method on 
    the member "dictionary" but I throw a NotSupportedException for the methods Add,
    Remove and Clear

    // I tried to support this one but I cannot compare a TValue with another TValue
    // by using == since the compiler doesn't know if TValue is a struct or a class etc
    // So either I add a generic constraint to only support classes (or ?) or I simply
    // don't support this method since it's ackward in a dictionary anyway to search by
    // value.  Users can still do it themselves if they insist.
    bool IEnumerable<TValue>.Contains(TValue value)
    {
        throw new System.NotSupportedException("A dictionary is not well suited to search by values");
    }

    public IEnumerator<TValue> GetEnumerator()
    {
        return (dictionary as IEnumerable<TValue>).GetEnumerator();
    }

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

然后，如果我的字典支持 TKey 和 TValue 的 IEnumerable，一切都变得如此简单：

public class MyDictionary : IDictionary<SomeKey,SomeValue>, 
                            IEnumerable<SomeKey>, 
                            IEnumerable<SomeValue>
{
    IEnumerator<SomeKey> IEnumerable<SomeKey>.GetEnumerator()
    {
        for ( int i = 0; i < nbElements; ++i )
        {
            yield return GetKeyAt(i);
        }
    }

    IEnumerator<SomeValue> IEnumerable<SomeValue>.GetEnumerator()
    {
        for ( int i = 0; i < nbElements; ++i )
        {
            yield return GetValueAt(i);
        }
    }

    // IEnumerator IEnumerable.GetEnumerator() is already implemented in the dictionary

    public ICollection<SomeKey> Keys
    {
        get
        {
            return new ReadOnlyKeyCollectionFromDictionary< MyDictionary, SomeKey, SomeValue>(this);
        }
    }

    public ICollection<Value> Values
    {
        get
        {
            return new ReadOnlyValueCollectionFromDictionary< MyDictionary, SomeKey, SomeValue >(this);
        }
    }
}

太糟糕了 IDictionary 没有为属性键和值返回 IEnumerable 而不是 ICollection。这一切本来会容易得多！

于 2013-02-07T19:33:24.583 回答