Как определить, является ли тип другим универсальным типом

if (typeof(IEnumerable).IsAssignableFrom(typeof(V))) {

Я не уверен, что понимаю, что вы здесь имеете в виду. Вы хотите знать, является ли объект любой общий тип, или вы хотите проверить, является ли он конкретный универсальный тип? Или вы просто хотите знать, можно ли перечислить?

Не думаю, что первое возможно. Второй вариант определенно возможен, просто относитесь к нему как к любому другому типу. Что касается третьего, просто протестируйте его на IEnumerable, как вы предложили.

Кроме того, вы не можете использовать оператор is для типов.

// Not allowed
if (string is Object)
  Foo();
// You have to use 
if (typeof(object).IsAssignableFrom(typeof(string))
  Foo();

Подробнее см. этот вопрос о типах. Может, это тебе поможет.

Вы хотите проверить метод Тип.IsInstanceOfType

Я бы использовал перегрузку:

public static void DoSomething<K,V>(IDictionary<K,V> items)
  where V : IEnumerable
{
   items.Keys.Each(key => { /* do something */ });
}

public static void DoSomething<K,V>(IDictionary<K,V> items)
{
   items.Keys.Each(key => { /* do something else */ });
}

Ранее принятый ответ - это хорошо, но это неправильно. К счастью, ошибка небольшая. Проверки IEnumerable недостаточно, если вы действительно хотите знать об общей версии интерфейса; существует множество классов, реализующих только неуниверсальный интерфейс. Я отвечу через минуту. Однако сначала я хотел бы отметить, что принятый ответ слишком сложен, поскольку следующий код даст то же самое при данных обстоятельствах:

if (items[key] is IEnumerable)

Это даже больше, потому что это работает для каждого элемента отдельно (а не для их общего подкласса V).

Теперь о правильном решении. Это немного сложнее, потому что мы должны взять универсальный тип IEnumerable`1 (то есть тип IEnumerable<> с одним параметром типа) и ввести правильный универсальный аргумент:

static bool IsGenericEnumerable(Type t) {
    var genArgs = t.GetGenericArguments();
    if (genArgs.Length == 1 &&
            typeof(IEnumerable<>).MakeGenericType(genArgs).IsAssignableFrom(t))
        return true;
    else
        return t.BaseType != null && IsGenericEnumerable(t.BaseType);
}

Вы можете легко проверить правильность этого кода:

var xs = new List<string>();
var ys = new System.Collections.ArrayList();
Console.WriteLine(IsGenericEnumerable(xs.GetType()));
Console.WriteLine(IsGenericEnumerable(ys.GetType()));

дает:

True
False

Не беспокойтесь о том, что здесь используется отражение. Хотя это правда, что это увеличивает накладные расходы времени выполнения, так же как и использование оператора is.

Конечно, приведенный выше код ужасно ограничен и может быть расширен до более универсального метода IsAssignableToGenericType. Следующая реализация немного некорректна: ¹, и я оставлю ее здесь только для исторических целей. Не используйте это. Вместо этого Джеймс представил в своем ответе отличную и правильную реализацию.

public static bool IsAssignableToGenericType(Type givenType, Type genericType) {
    var interfaceTypes = givenType.GetInterfaces();

    foreach (var it in interfaceTypes)
        if (it.IsGenericType)
            if (it.GetGenericTypeDefinition() == genericType) return true;

    Type baseType = givenType.BaseType;
    if (baseType == null) return false;

    return baseType.IsGenericType &&
        baseType.GetGenericTypeDefinition() == genericType ||
        IsAssignableToGenericType(baseType, genericType);
}

¹ Не работает, если genericType совпадает с givenType; по той же причине он не работает для типов, допускающих значение NULL, т.е.

IsAssignableToGenericType(typeof(List<int>), typeof(List<>)) == false
IsAssignableToGenericType(typeof(int?), typeof(Nullable<>)) == false

Я создал gist с исчерпывающим набором тестовых примеров.

Предупреждение об общих типах и использовании IsAssignableFrom () ...

Допустим, у вас есть следующее:

public class MyListBase<T> : IEnumerable<T> where T : ItemBase
{
}

public class MyItem : ItemBase
{
}

public class MyDerivedList : MyListBase<MyItem>
{
}

Вызов IsAssignableFrom для типа базового списка или для производного типа списка вернет false, но очевидно, что MyDerivedList наследует MyListBase<T>. (Небольшое замечание для Джеффа, универсальные типы должен должны быть заключены в блок кода или тильды, чтобы получить <T>, в противном случае он опускается. Это задумано?) Проблема связана с тем, что MyListBase<MyItem> рассматривается как совершенно другой тип, чем MyListBase<T>. Следующая статья могла бы объяснить это немного лучше. http://mikehadlow.blogspot.com/2006/08/reflecting-generics.html

Вместо этого попробуйте следующую рекурсивную функцию:

    public static bool IsDerivedFromGenericType(Type givenType, Type genericType)
    {
        Type baseType = givenType.BaseType;
        if (baseType == null) return false;
        if (baseType.IsGenericType)
        {
            if (baseType.GetGenericTypeDefinition() == genericType) return true;
        }
        return IsDerivedFromGenericType(baseType, genericType);
    }

/ EDIT: новый пост Конрада, который учитывает общую рекурсию, а также интерфейсы, находится на высоте. Очень хорошая работа. :)

/ EDIT2: если выполняется проверка, является ли genericType интерфейсом, можно получить преимущества в производительности. Проверка может быть блоком if вокруг текущего кода интерфейса, но если вы заинтересованы в использовании .NET 3.5, мой друг предлагает следующее:

    public static bool IsAssignableToGenericType(Type givenType, Type genericType)
    {
        var interfaces = givenType.GetInterfaces().Where(it => it.IsGenericType).Select(it => it.GetGenericTypeDefinition());
        var foundInterface = interfaces.FirstOrDefault(it => it == genericType);
        if (foundInterface != null) return true;

        Type baseType = givenType.BaseType;
        if (baseType == null) return false;

        return baseType.IsGenericType ?
            baseType.GetGenericTypeDefinition() == genericType :
            IsAssignableToGenericType(baseType, genericType);
    }

Раньше я думал, что такая ситуация может быть решена способом, аналогичным решение @Thomas Danecker, но с добавлением еще одного аргумента шаблона:

public static void DoSomething<K, V, U>(IDictionary<K,V> items)
    where V : IEnumerable<U> { /* do something */ }
public static void DoSomething<K, V>(IDictionary<K,V> items)
                             { /* do something else */ }

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

Я был бы очень благодарен, если бы кто-нибудь мог указать на что-нибудь неправильное, что я мог здесь сделать.

Большое спасибо за этот пост Я хотел предоставить версию решения Конрада Рудольфа, которая мне больше подошла. У меня были незначительные проблемы с этой версией, особенно при проверке, является ли Type типом значения, допускающим значение NULL:

public static bool IsAssignableToGenericType(Type givenType, Type genericType)
{
    var interfaceTypes = givenType.GetInterfaces();

    foreach (var it in interfaceTypes)
    {
        if (it.IsGenericType && it.GetGenericTypeDefinition() == genericType)
            return true;
    }

    if (givenType.IsGenericType && givenType.GetGenericTypeDefinition() == genericType)
        return true;

    Type baseType = givenType.BaseType;
    if (baseType == null) return false;

    return IsAssignableToGenericType(baseType, genericType);
}

Спасибо за отличную информацию. Для удобства я преобразовал это в метод расширения и сократил его до одного оператора.

public static bool IsAssignableToGenericType(this Type givenType, Type genericType)
{
  return givenType.GetInterfaces().Any(t => t.IsGenericType && t.GetGenericTypeDefinition() == genericType) ||
         givenType.BaseType != null && (givenType.BaseType.IsGenericType && givenType.BaseType.GetGenericTypeDefinition() == genericType ||
                                        givenType.BaseType.IsAssignableToGenericType(genericType));
}

Теперь его можно легко вызвать с помощью:

sometype.IsAssignableToGenericType (typeof (MyGenericType <>))