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.

Answer 1

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.

Answer 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>()

Answer 3

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() { }
}