Come ottenere il tipo di T da un membro di una classe o metodo generico?

Supponiamo che io abbia un membro generico in una classe o in un metodo, quindi:

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

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

Quando ho un'istanza della classe, l' Tdiviene MyTypeObject1, quindi la classe ha una proprietà elenco generico: List<MyTypeObject1>. Lo stesso vale per un metodo generico in una classe non generica:

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

        // get type of T
    }
}

Vorrei sapere quale tipo di oggetti contiene l'elenco della mia classe. Quindi la proprietà list chiamata Baro la variabile locale baz, contiene che tipo di T?

Non posso farlo Bar[0].GetType(), perché l'elenco potrebbe contenere zero elementi. Come posso farlo?

Se ho capito bene, la tua lista ha lo stesso parametro di tipo della classe contenitore stessa. In questo caso, quindi:

Type typeParameterType = typeof(T);

Se sei nella fortunata situazione di avere objectcome parametro di tipo, vedi la risposta di Marc .

(nota: presumo che tutto ciò che sai sia objecto IListo simile e che l'elenco potrebbe essere di qualsiasi tipo in fase di esecuzione)

Se sai che è un List<T>, quindi:

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

Un'altra opzione è guardare l'indicizzatore:

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

Utilizzando il nuovo TypeInfo:

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

Con il seguente metodo di estensione puoi cavartela senza riflettere:

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

O più generale:

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

Uso:

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

Provare

list.GetType().GetGenericArguments()

Questo è lavoro per me. Dove myList è un tipo sconosciuto di elenco.

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

Se non hai bisogno dell'intera variabile Type e vuoi solo controllare il tipo, puoi facilmente creare una variabile temp e usare is operator.

T checkType = default(T);

if (checkType is MyClass)
{}

È possibile utilizzare questo per il tipo di ritorno dell'elenco generico:

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

Considera questo: lo uso per esportare 20 elenchi digitati allo stesso modo:

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

Uso questo metodo di estensione per realizzare qualcosa di simile:

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

Lo usi in questo modo:

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

Questo non è proprio quello che stai cercando, ma è utile per dimostrare le tecniche coinvolte.

Il GetGenericArgument()metodo deve essere impostato sul Tipo di base dell'istanza (la cui classe è una classe generica myClass<T>). Altrimenti, restituisce un tipo [0]

Esempio:

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

È possibile ottenere il tipo di "T" da qualsiasi tipo di raccolta che implementa IEnumerable <T> con il seguente:

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

Si noti che non supporta i tipi di raccolta che implementano IEnumerable <T> due volte, ad es

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

Suppongo che potresti restituire una serie di tipi se dovessi supportare questo ...

Inoltre, potresti voler memorizzare nella cache il risultato per tipo di raccolta se lo stai facendo molto (ad esempio in un ciclo).

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

Utilizzando la soluzione di 3dGrabber:

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

//and now 

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

Se vuoi conoscere il tipo sottostante di una proprietà, prova questo:

propInfo.PropertyType.UnderlyingSystemType.GenericTypeArguments[0]

È così che l'ho fatto

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

Quindi chiamalo così

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

O

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

Genere:

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