C#和#x27；s相当于Java'；s通配符

如果存在，以下Java代码的C#等价物是什么：

new HashMap<Class<? extends BaseClass>, Integer>();

newhashmap，Integer>（）

这显然是不同的

（忽略

HashMap

和

Dictionary

之间的差异）

---

编辑：为了澄清这一点，我不想定义一个新类，只需创建一个

HashMap

/

字典的实例

我相信您希望将类型参数约束到泛型类型-关键字用于：

class MyDict<TKey, TValue> : Dictionary<TKey, TValue> where TValue : SomeBaseClass
{
    ...
}

---

我想这很接近你想要的。如果我误解了，请发表评论-我对Java的了解没有这么深。

在C#中没有Java通配符的等价物。在Java中，类型的类型是

Class

，其中

T

是类本身。C#中的等价物是类型

type

，它不是泛型的。因此，正如您所说，您所能做的最好的事情就是拥有一个

字典

，如果它被封装在一个类中，您可以限制您在代码中放入字典的内容（因此它只是一个运行时检查）：

（同时实现

等于

和

获取hashcode

，只需委托给

类型

）

然后你的字典变成：

var d = new Dictionary<TypeWrapper<BaseClass>, int>();
d.Add(typeof(BaseClass), 2);
d.Add(typeof(Child), 3);

var d=newdictionary（）；
d、 添加（类型（基类），2）；
d、 添加（类型（儿童），3）；

也在研究同样的问题，这个可怜的人的支票是我能想出的最好的办法：

class MyValue {
    public Type Type { get; private set; }

    private MyValue(Type type)
    {
        this.Type = type;
    }

    public MyValue of<T>() where T : BaseClass
    {
        return new MyValue(typeof(T));
    }
}

IDictionary<int, MyValue> myDictionary = new Dictionary<int, MyValue>()
{
    { 1, MyValue.of<SubClass1>(); },
    { 2, MyValue.of<SubClass2>(); },
    { 3, MyValue.of<NotSubClass>(); }, // this causes a compile error
};

类MyValue{
公共类型类型{get；private set；}
私有MyValue（类型）
{
this.Type=Type；
}
（）的公共MyValue，其中T:BaseClass
{
返回新的MyValue（typeof（T））；
}
}
IDictionary myDictionary=新字典（）
{
{1，MyValue.of（）；}，
{2，MyValue.of（）；}，
{3，MyValue.of（）；}，//这会导致编译错误
};

appeably replicate@halex我看到了这个问题，它很相似——但绝对不一样。OP并没有声明一个类。。。在C#@Thomasleveque中，他试图做的是不可能的——你似乎是对的——在编辑之后，它似乎是一个函数调用。我试图做的是用

类型作为键的
字典
，但不仅仅是任何类型-只有
类型
来自派生自某个基类的类。@我明白了-你不能在C#中声明性地这样做-你只能执行运行时检查，就像Jordão的回答一样。我误解了你的意思。你说得很对。我想要的是编译时检查，或者至少是运行时检查，而不必修改大量额外代码或创建新类型。从答案来看，在C#中似乎真的没有这样的等价物。。。真可惜。
public class TypeWrapper<T>
{
    public Type Type { get; private set; }
    public TypeWrapper(Type t)
    {
        if (!typeof(T).IsAssignableFrom(t)) throw new Exception();
        Type = t;
    }
    public static implicit operator TypeWrapper<T>(Type t) {
        return new TypeWrapper<T>(t);
    }
}

var d = new Dictionary<TypeWrapper<BaseClass>, int>();
d.Add(typeof(BaseClass), 2);
d.Add(typeof(Child), 3);

class MyValue {
    public Type Type { get; private set; }

    private MyValue(Type type)
    {
        this.Type = type;
    }

    public MyValue of<T>() where T : BaseClass
    {
        return new MyValue(typeof(T));
    }
}

IDictionary<int, MyValue> myDictionary = new Dictionary<int, MyValue>()
{
    { 1, MyValue.of<SubClass1>(); },
    { 2, MyValue.of<SubClass2>(); },
    { 3, MyValue.of<NotSubClass>(); }, // this causes a compile error
};