在 C# 中：如何声明一个类型为键的通用字典，该类型的 IEnumerable<> 作为值？

Question

我想声明一个字典，存储特定类型的输入IEnumerable，以该确切类型作为键，如下所示：（编辑以遵循 johny g 的评论）

private IDictionary<Type, IEnumerable<T>> _dataOfType where T: BaseClass; //does not compile!

我要存储的具体类都派生自 BaseClass，因此我想将其用作约束。编译器抱怨它需要在成员名称后加一个分号。

如果可行，我希望这将使以后从字典中检索变得简单，例如：

IEnumerable<ConcreteData> concreteData;
_sitesOfType.TryGetValue(typeof(ConcreteType), out concreteData);

如何定义这样的字典？

Answer 1

使用 .Net 框架中已有的 System.ComponentModel.Design.ServiceContainer。

        ServiceContainer container = new ServiceContainer();

        IList<int> integers = new List<int>();
        IList<string> strings = new List<string>();
        IList<double> doubles = new List<double>();

        container.AddService(typeof(IEnumerable<int>), integers);
        container.AddService(typeof(IEnumerable<string>), strings);
        container.AddService(typeof(IEnumerable<double>), doubles);

Answer 2

您甚至可能不需要字典就能做到这一点 - 但这取决于您的需要。如果每个 appdomain 的每个类型只需要 1 个这样的列表（即“字典”是 static），那么以下模式可以有效并很好地促进类型推断：

interface IBase {}

static class Container {
    static class PerType<T> where T : IBase {
        public static IEnumerable<T> list;
    }

    public static IEnumerable<T> Get<T>() where T : IBase 
        => PerType<T>.list; 

    public static void Set<T>(IEnumerable<T> newlist) where T : IBase 
        => PerType<T>.list = newlist;

    public static IEnumerable<T> GetByExample<T>(T ignoredExample) where T : IBase 
        => Get<T>(); 
}

请注意，在采用这种方法之前，您应该仔细考虑编译时类型和运行时类型之间的区别。这个方法可以让你在SomeType和SomeType的任何基本类型下存储一个运行时类型的IEnumerable<SomeType>变量，包括IBase，既没有运行时错误，也没有编译类型错误- 这可能是一个功能，或者是一个等待发生的错误，所以你可能需要if 来检查。

此外，这种方法忽略了线程；因此，如果您想从多个线程访问此数据结构，您可能需要添加一些锁定。引用读/写是原子的，因此如果您未能锁定，您不会受到损坏，但陈旧数据和竞争条件肯定是可能的。

Answer 3

您不要将T 限制在私有成员中；您将其限制在类级别。

class Foo<T> where T : BaseClass
{
    private IDictionary<T, IEnumerable<T>> _dataOfType;

    public Foo(IDictionary<T, IEnumerable<T>> dataOfType)
    {
        this._dataOfType = dataOfType;
    }   
}   

Answer 4

1. 您不能约束特定变量。它仅适用于类和方法。老实说，这在变量级别上真的没有任何意义。
2. 您想要的是一个自定义类 - class WeirdDictionary : IDictionary<Type, IEnumerable>，它将重载 Add 方法以采用该类型的类型和 IEnumerable，您可以使用约束来执行此操作，并将 IEnumerable 强制转换为 IEnumerable。同时重载索引器，并将其转换回相关类型。
   所有这些转换都是必需的，因为泛型严格要求 IEnumerable<Base> 与 IEnumerable<Derived> 一样好（我相信这称为方差？）

这个解决方案有点笼统，因为重用岩石

由 280Z28 编辑：

起初我把它记下来，因为第 2 点令人困惑并且我误解了它。通过使用IDictionary<Type, IEnumerable> 中方法的显式实现并提供通用替代方案，您可以获得一个非常干净的接口。请注意，您无法创建通用索引器，因此您必须始终使用TryGet<T>（无论如何这是个好主意）。我只包含了IDictionary<> 方法之一的显式实现，以展示如何执行检查。 不要直接从Dictionary<Type, IEnumerable> 派生WeirdDictionary，否则您将失去在基础数据中保证约束的能力。

class WeirdDictionary : IDictionary<Type, IEnumerable>
{
    private readonly Dictionary<Type, IEnumerable> _data =
        new Dictionary<Type, IEnumerable>();

    public void Add<T>(IEnumerable<T> value)
    {
        _data.Add(typeof(T), value);
    }

    public bool TryGet<T>(out IEnumerable<T> value)
    {
        IEnumerable enumerable;
        if (_data.TryGetValue(typeof(T), out enumerable)
        {
            value = (IEnumerable<T>)enumerable;
            return true;
        }

        value = null;
        return false;
    }

    // use explicit implementation to discourage use of this method since
    // the manual type checking is much slower that the generic version above
    void IDictionary<Type, IEnumerable>.Add(Type key, IEnumerable value)
    {
        if (key == null)
            throw new ArgumentNullException("key");
        if (value != null && !typeof(IEnumerable<>).MakeGenericType(key).IsAssignableFrom(value.GetType()))
            throw new ArgumentException(string.Format("'value' does not implement IEnumerable<{0}>", key));

        _data.Add(key, value);
    }
}

结束 280Z28

Answer 5

制作一个自定义 Dictionary 类：

public class BaseClassDictionary<T, IEnumerable<T>> : Dictionary<T, IEnumerable<T>>
    where T : BaseClass
{
}

然后你可以使用这个专门的字典来代替字段类型：

private BaseClassDictionary<BaseClassDerivedType, IEnumerable<BaseClassDerivedType>> myDictionary;

Answer 6

试试这个：

public class MyCustomDictionary<T>: Dictionary<T, IEnumerable<T>>  { }