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

Question

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 T devient MyTypeObject1, de sorte que la classe a une propriété de liste générique: List<MyTypeObject1>. De même pour 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 la liste de ma classe contient. Ainsi, la propriété de liste appelée Bar ou la variable locale baz, contient quel type de T?

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

Answer 1

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

Type typeParameterType = typeof(T); 

Si vous êtes dans la situation de la chance d'avoir object comme paramètre de type, voir Marc's answer.

Answer 2

(note: Je suppose que tout ce que vous connaissez est object ou IList ou similaire, et que la liste pourrait être tout type à l'exécution)

Si vous le savez est un List<T>, puis:

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

Une autre option est de regarder l'indexeur:

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

nouvelle aide TypeInfo:

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

Answer 3

Essayez

list.GetType().GetGenericArguments() 

Answer 4

Type:

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

Answer 5

Considérez ceci: Je l'utilise pour exporter 20 liste dactylographiée par même:

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

Answer 6

La méthode GetGenericArgument() doit être mis sur le type de base de votre instance (dont la classe est une classe générique myClass<T>). Dans le cas contraire, elle renvoie un type [0]

Exemple:

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

Answer 7

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

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

Answer 8

Avec la méthode d'extension suivante, vous pouvez partir 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); 
} 

Utilisation:

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 

Answer 9

Vous pouvez obtenir le type de "T" de n'importe quel type de collection qui implémente IEnumerable <T> ce qui suit:

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 supporte pas les types de collections qui mettent en œuvre IEnumerable <T> deux fois, par exemple

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

Je suppose que vous pourriez retourner un tableau de types si vous avez besoin pour soutenir cette ...

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

Answer 10

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

Vous pouvez l'utiliser 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 cherchez, mais il est utile dans démontrer les techniques impliquées.

Answer 11

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

Answer 12

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 temp et utiliser l'opérateur.

T checkType = default(T); 

if (checkType is MyClass) 
{} 

Answer 13

En utilisant 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(); 

Answer 14

Si vous voulez savoir type sous-jacent d'une propriété, essayez ceci:

propInfo.PropertyType.UnderlyingSystemType.GenericTypeArguments[0] 

Answer 15

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

Vous pouvez utiliser celui-ci pour le type réexécutez de liste générique.

Answer 16

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

Puis appelle comme ça

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

OU

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