Подстановочный знак в С# generics

Скажем, у меня есть общий класс следующим образом:

public class GeneralPropertyMap<T>
{
}

В каком-то другом классе у меня есть метод, который принимает массив GeneralPropertyMap<T>. В Java, чтобы взять массив, содержащий любой тип GeneralPropertyMap метод будет выглядеть так:

private void TakeGeneralPropertyMap(GeneralPropertyMap<?>[] maps)
{
}

Мы используем подстановочный знак, чтобы позже мы могли вызвать TakeGeneralPropertyMap передавая кучу GeneralPropertyMap с любым типом для T каждый, например:

GeneralPropertyMap<?>[] maps = new GeneralPropertyMap<?>[3];
maps[0] = new GeneralPropertyMap<String>();
maps[1] = new GeneralPropertyMap<Integer>();
maps[2] = new GeneralPropertyMap<Double>();
//And finally pass the array in.
TakeGeneralPropertyMap(maps);

Я пытаюсь найти эквивалент в С# без успеха. Есть идеи?

Ответ 1

Дженерики в С# обеспечивают более надежные гарантии, чем generics в Java. Поэтому, чтобы делать то, что вы хотите на С#, вы должны позволить классу GeneralPropertyMap<T> наследовать от не-универсальной версии этого класса (или интерфейса).

public class GeneralPropertyMap<T> : GeneralPropertyMap
{
}

public class GeneralPropertyMap
{
    // Only you can implement it:
    internal GeneralPropertyMap() { }
}

Теперь вы можете сделать:

private void TakeGeneralPropertyMap(GeneralPropertyMap[] maps)
{
}

А также:

GeneralPropertyMap[] maps = new GeneralPropertyMap[3];
maps[0] = new GeneralPropertyMap<String>();
maps[1] = new GeneralPropertyMap<Integer>();
maps[2] = new GeneralPropertyMap<Double>();
TakeGeneralPropertyMap(maps);

Ответ 2

Хотя, как отмечали другие, нет точного соответствия подстановочным символам в С#, некоторые из их вариантов использования могут быть покрыты ковариацией/контравариантностью.

public interface IGeneralPropertyMap<out T> {} // a class can't be covariant, so 
                                        // we need to introduce an interface...

public class GeneralPropertyMap<T> : IGeneralPropertyMap<T> {} // .. and have our class
                                                            // inherit from it

//now our method becomes something like
private void TakeGeneralPropertyMap<T>(IList<IGeneralPropertyMap<T>> maps){}

// and you can do
    var maps = new List<IGeneralPropertyMap<Object>> {
        new GeneralPropertyMap<String>(),
        new GeneralPropertyMap<Regex>()
    };
    //And finally pass the array in.
    TakeGeneralPropertyMap<Object>(maps);

Предостережение заключается в том, что вы не можете использовать ковариацию с типами значений, поэтому добавление нового GeneralPropertyMap<int>() в наш список не выполняется во время компиляции.

cannot convert from 'GeneralPropertyMap<int>' to 'IGeneralPropertyMap<object>'

Этот подход может быть более удобным, чем наличие универсальной версии ваших классов/интерфейсов, если вы хотите ограничить типы, которые может содержать GeneralPropertyMap. В таком случае:

public interface IMyType {}
public class A : IMyType {}
public class B : IMyType {}
public class C : IMyType {}

public interface IGeneralPropertyMap<out T> where T : IMyType {}

позволяет:

var maps = new List<IGeneralPropertyMap<IMyType>> {
    new GeneralPropertyMap<A>(),
    new GeneralPropertyMap<B>() ,
    new GeneralPropertyMap<C>() 
};
TakeGeneralPropertyMap(maps);

Ответ 3

В С# нет прямого эквивалента этому.

В С# это часто можно сделать, если ваш универсальный класс реализует не общий интерфейс или базовый класс:

interface IPropertyMap
{
   // Shared properties
}

public class GeneralPropertyMap<T> : IPropertyMap
{
}

Затем вы можете передать массив из них:

IPropertyMap[] maps = new IPropertyMap[3];
// ...

TakePropertyMap(maps);

Ответ 4

Сделать интерфейс из членов GeneralPropertyMap (IGeneralPropertyMap), а затем принять IGeneralPropertyMap[] в качестве аргумента.

Ответ 5

На самом деле, вы можете получить довольно близко к шаблону с помощью динамического. Это также хорошо работает, если у вас не универсальный суперкласс.

Например:

public class A
{
  // ...
}

public class B<T> : A
{
  // ...
}

public class Program
{
  public static A MakeA() { return new A(); }

  public static A MakeB() { return new B<string>(); }

  public static void Visit<T>(B<T> b)
  {
    Console.WriteLine("This is B with type "+typeof(T).FullName);
  }

  public static void Visit(A a)
  {
    Console.WriteLine("This is A");
  }

  public static void Main()
  {
    A instA = MakeA();
    A instB = MakeB();

    // This calls the appropriate methods.
    Visit((dynamic)instA);
    Visit((dynamic)instB);

    // This calls Visit(A a) twice.
    Visit(instA);
    Visit(instB);
  }
}

Как это работает, объясняется в документации по С# здесь.