Question about generics in C# comparing to Java

Question

In Java I can specify generic with wildcard "?". It is possible to create a map like this one:

Map<String, ?>.

I'm working with C# and I need a Dictionary<String, SomeInterface<?>> (where ? can be int, double, any type). Is this possible in C#?

EDIT:

Example:

interface ISomeInterface<out T>{
 T Method();
 void methodII();
}

class ObjectI : ISomeInterface<int>{
    ...
}
class ObjectII : ISomeInterface<double>{
    ...
}
class ObjectIII : ISomeInterface<string>{
    ....
}

I was trying to map this objects into Dictionary like:

Dictionary<String, ISomeInterface<?>> _objs = new Dictionary<String, ISomeInterface<?>();

_objs.Add("Object1", new ObjectI());
_objs.Add("Object2", new ObjectII());
_objs.Add("Object3", new ObjectII());

foreach(var keyVal in _objs){
   Console.WriteLine(keyVal.Method());
}

Objects that implement ISomeInterface are loaded in runtime using Assembly and Activator.createInstance. In the moment of creation I don't if objects implements ISomeInterface<int> or ISomeInterface<double>.

Any help is very much appreciated.

I don't know Java that much but wouldn't `?` be the same as `Object` then? — Chris Haas, May 12 '11 at 15:22
Yes, `?` is `Object`. What's more unexpected is that *anything* you write there is actually `Object`, because Java's VM doesn't actually support generics, so they all get erased at compile time. — Blindy, May 12 '11 at 15:24

SLaks · Accepted Answer · 2011-05-12T16:12:12.890

No.

However, if you're using C# 4, you can make ISomeInterface covariant so that ISomeInterface<Anything> will be convertible to ISomeInterface<object>.

If ISomeInterface has methods that take parameters of its type parameter (as opposed to return values), this will be completely impossible, since it would then allow you to pass arbitrary objects as the parameters.

EDIT: In your specific case, the best solution is to make IMyInterface<T> inherit a separate non-generic IMyInterface interface and move all members that don't involve T to the base interface.
You can then use a Dictionary<string, IMyInterface> and you won't have any trouble.

score 2 · Answer 2 · answered May 12 '11 at 15:18

2

There is the possibility to restrict your type variables to certain types:

public class Map<U, T> where T : IInterface
{
}

However, you can't do something like:

Map<string, T> map = new Map<string, T>()

answered May 12 '11 at 15:18

Femaref

60,705
7
138
176

Hosam Aly · Answer 3 · 2011-05-12T16:45:24.767

2

For the usage you're describing, you could use a workaround, with an IDictionary<string, ISomeInterface>:

interface ISomeInterface
{
    object Method();
    void Method2();
}

interface ISomeInterface<T> : ISomeInterface
{
    T Method();
}

class C1 : ISomeInterface<int>
{
    object ISomeInterface.Method() { return Method(); }
    public int Method() { return 10; }
    public void Method2() { }
}

edited May 12 '11 at 16:45

answered May 12 '11 at 16:17

Hosam Aly

41,555
36
141
182

Question about generics in C# comparing to Java

3 Answers3