Comment obtenir le type de T d'un membre d'une classe ou d'une méthode générique?

Disons que j'ai un membre générique dans une classe ou une méthode, donc:

public class Foo<T>
{
    public List<T> Bar { get; set; }

    public void Baz()
    {
        // get type of T
    }   
}

Quand j'instancier la classe, le Tdevient MyTypeObject1, si la classe a une propriété de liste générique: List<MyTypeObject1>. La même chose s'applique à une méthode générique dans une classe non générique:

public class Foo
{
    public void Bar<T>()
    {
        var baz = new List<T>();

        // get type of T
    }
}

Je voudrais savoir quel type d'objets contient la liste de ma classe. Ainsi, la propriété list appelée Barou la variable locale baz, contient quel type de T?

Je ne peux pas le faire Bar[0].GetType(), car la liste peut contenir zéro élément. Comment puis-je le faire?

Si je comprends bien, votre liste a le même paramètre de type que la classe de conteneur elle-même. Si tel est le cas, alors:

Type typeParameterType = typeof(T);

Si vous avez la chance d'avoir objectcomme paramètre de type, voyez la réponse de Marc .

(note: je suppose que tout ce que vous savez est objectou IListou similaire, et que la liste peut être de n'importe quel type au moment de l'exécution)

Si vous savez que c'est un List<T>, alors:

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

Une autre option consiste à regarder l'indexeur:

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

Utilisation de la nouvelle TypeInfo:

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

Avec la méthode d'extension suivante, vous pouvez vous évader sans réflexion:

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

Ou plus général:

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

Usage:

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

Essayer

list.GetType().GetGenericArguments()

C'est du travail pour moi. Où myList est une sorte de liste inconnue.

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

Si vous n'avez pas besoin de la variable Type entière et que vous voulez simplement vérifier le type, vous pouvez facilement créer une variable temporaire et utiliser son opérateur.

T checkType = default(T);

if (checkType is MyClass)
{}

Vous pouvez utiliser celui-ci pour le type de retour de liste générique:

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

Considérez ceci: je l'utilise pour exporter 20 listes dactylographiées de la même manière:

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);
    }
}

J'utilise cette méthode d'extension pour accomplir quelque chose de similaire:

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;
}

Vous l'utilisez comme ceci:

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

Ce n'est pas tout à fait ce que vous recherchez, mais c'est utile pour démontrer les techniques impliquées.

La GetGenericArgument()méthode doit être définie sur le type de base de votre instance (dont la classe est une classe génériquemyClass<T> ). Sinon, il renvoie un type [0]

Exemple:

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

Vous pouvez obtenir le type de "T" à partir de n'importe quel type de collection qui implémente IEnumerable <T> avec les éléments suivants:

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;
}

Notez qu'il ne prend pas en charge les types de collection qui implémentent IEnumerable <T> deux fois, par exemple

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

Je suppose que vous pourriez renvoyer un tableau de types si vous aviez besoin de prendre en charge cela ...

En outre, vous pouvez également vouloir mettre en cache le résultat par type de collection si vous faites beaucoup cela (par exemple dans une boucle).

public bool IsCollection<T>(T value){
  var valueType = value.GetType();
  return valueType.IsArray() || typeof(IEnumerable<object>).IsAssignableFrom(valueType) || typeof(IEnumerable<T>).IsAssignableFrom(valuetype);
}

Utilisation de la solution de 3dGrabber:

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

//and now 

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

Si vous souhaitez connaître le type sous-jacent d'une propriété, essayez ceci:

propInfo.PropertyType.UnderlyingSystemType.GenericTypeArguments[0]

C'est comme ça que je l'ai fait

internal static Type GetElementType(this Type type)
{
        //use type.GenericTypeArguments if exist 
        if (type.GenericTypeArguments.Any())
         return type.GenericTypeArguments.First();

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

Alors appelle ça comme ça

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

OU

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

Type:

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