Как получить тип T от члена универсального класса или метода

Если я правильно понимаю, ваш список имеет тот же параметр типа, что и сам класс контейнера. Если это так, то:

Type typeParameterType = typeof(T);

Если вам посчастливилось иметь object в качестве параметра типа, см. ответ Марка.

(примечание: я предполагаю, что все, что вы знаете, это object, IList или аналогичные, и что список может быть любого типа во время выполнения)

Если вы знаете, что это List<T>, тогда:

Type type = abc.GetType().GetGenericArguments()[0];

Другой вариант - посмотреть индексатор:

Type type = abc.GetType().GetProperty("Item").PropertyType;

Использование нового TypeInfo:

using System.Reflection;
// ...
var type = abc.GetType().GetTypeInfo().GenericTypeArguments[0];

С помощью следующего метода расширения вы можете обойтись без размышлений:

public static Type GetListType<T>(this List<T> _)
{
    return typeof(T);
}

Или более общий:

public static Type GetEnumeratedType<T>(this IEnumerable<T> _)
{
    return typeof(T);
}

Использование:

List<string>        list    = new List<string> { "a", "b", "c" };
IEnumerable<string> strings = list;
IEnumerable<object> objects = list;

Type listType    = list.GetListType();           // string
Type stringsType = strings.GetEnumeratedType();  // string
Type objectsType = objects.GetEnumeratedType();  // BEWARE: object

Пытаться

list.GetType().GetGenericArguments()

Следующее работает для меня. Где myList - это какой-то неизвестный список.

IEnumerable myEnum = myList as IEnumerable;
Type entryType = myEnum.AsQueryable().ElementType;

Если вам не нужна вся переменная Type и вы просто хотите проверить тип, вы можете легко создать временную переменную и использовать оператор is.

T checkType = default(T);

if (checkType is MyClass)
{}

Вы можете использовать его для типа возвращаемого значения общего списка:

public string ListType<T>(T value)
{
    var valueType = value.GetType().GenericTypeArguments[0].FullName;
    return valueType;
}

Учти это:

Я использую его для экспорта 20 типизированных списков таким же образом:

private void Generate<T>()
{
    T item = (T)Activator.CreateInstance(typeof(T));

    ((T)item as DemomigrItemList).Initialize();

    Type type = ((T)item as DemomigrItemList).AsEnumerable().FirstOrDefault().GetType();
    if (type == null) 
        return;
    if (type != typeof(account)) // Account is listitem in List<account>
    {
        ((T)item as DemomigrItemList).CreateCSV(type);
    }
}

Я использую этот метод расширения для чего-то подобного:

public static string GetFriendlyTypeName(this Type t)
{
    var typeName = t.Name.StripStartingWith("`");
    var genericArgs = t.GetGenericArguments();
    if (genericArgs.Length > 0)
    {
        typeName += "<";
        foreach (var genericArg in genericArgs)
        {
            typeName += genericArg.GetFriendlyTypeName() + ", ";
        }
        typeName = typeName.TrimEnd(',', ' ') + ">";
    }
    return typeName;
}

public static string StripStartingWith(this string s, string stripAfter)
{
    if (s == null)
    {
        return null;
    }
    var indexOf = s.IndexOf(stripAfter, StringComparison.Ordinal);
    if (indexOf > -1)
    {
        return s.Substring(0, indexOf);
    }
    return s;
}

Вы используете это так:

[TestMethod]
public void GetFriendlyTypeName_ShouldHandleReallyComplexTypes()
{
    typeof(Dictionary<string, Dictionary<string, object>>).GetFriendlyTypeName()
        .ShouldEqual("Dictionary<String, Dictionary<String, Object>>");
}

Это не совсем то, что вы ищете, но это полезно для демонстрации задействованных методов.

Вы можете получить тип «T» из любого типа коллекции, который реализует IEnumerable ‹T›, со следующим:

public static Type GetCollectionItemType(Type collectionType)
{
    var types = collectionType.GetInterfaces()
        .Where(x => x.IsGenericType 
            && x.GetGenericTypeDefinition() == typeof(IEnumerable<>))
        .ToArray();
    // Only support collections that implement IEnumerable<T> once.
    return types.Length == 1 ? types[0].GetGenericArguments()[0] : null;
}

Обратите внимание, что он не поддерживает типы коллекций, которые реализуют IEnumerable ‹T› дважды, например

public class WierdCustomType : IEnumerable<int>, IEnumerable<string> { ... }

Я полагаю, вы могли бы вернуть массив типов, если бы вам нужно было это поддержать ...

Кроме того, вы также можете захотеть кэшировать результат для каждого типа коллекции, если вы делаете это много (например, в цикле).

Метод GetGenericArgument() должен быть установлен для базового типа вашего экземпляра (класс которого является универсальным классом myClass<T>). В противном случае он возвращает тип [0].

Пример:

Myclass<T> instance = new Myclass<T>();
Type[] listTypes = typeof(instance).BaseType.GetGenericArguments();

Использование решение 3dGrabber:

public static T GetEnumeratedType<T>(this IEnumerable<T> _)
{
    return default(T);
}

//and now

var list = new Dictionary<string, int>();
var stronglyTypedVar = list.GetEnumeratedType();

Если вы хотите узнать базовый тип свойства, попробуйте следующее:

propInfo.PropertyType.UnderlyingSystemType.GenericTypeArguments[0]

Вот как я это сделал:

internal static Type GetElementType(this Type type)
{
    // Use type.GenericTypeArguments if it exists
    if (type.GenericTypeArguments.Any())
        return type.GenericTypeArguments.First();

    return type.GetRuntimeProperty("Item").PropertyType);
}

Тогда назовите это так:

var item = Activator.CreateInstance(iListType.GetElementType());

Or

var item = Activator.CreateInstance(Bar.GetType().GetElementType());

Тип:

type = list.AsEnumerable().SingleOrDefault().GetType();