Wie erhalte ich den Typ von T von einem Mitglied einer generischen Klasse oder Methode?

Angenommen, ich habe ein generisches Mitglied in einer Klasse oder Methode, also:

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

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

Wenn ich die Klasse instanziiere, Twird das MyTypeObject1, sodass die Klasse eine generische Listeneigenschaft hat : List<MyTypeObject1>. Gleiches gilt für eine generische Methode in einer nicht generischen Klasse:

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

        // get type of T
    }
}

Ich würde gerne wissen, welche Art von Objekten die Liste meiner Klasse enthält. Die aufgerufene Eigenschaft list Baroder die lokale Variable bazenthält also welche Art von T?

Ich kann nicht Bar[0].GetType(), weil die Liste möglicherweise keine Elemente enthält. Wie kann ich es tun?

Wenn ich das richtig verstehe, hat Ihre Liste den gleichen Typparameter wie die Containerklasse selbst. Wenn dies der Fall ist, dann:

Type typeParameterType = typeof(T);

Wenn Sie die glückliche Situation haben object, einen Typparameter zu haben, lesen Sie Marc's Antwort .

(Anmerkung: Ich gehe davon aus, dass alles , was Sie wissen , ist , objectoder IListoder ähnliches, und dass die Liste jede Art zur Laufzeit sein könnte)

Wenn Sie wissen, dass es ein ist List<T>, dann:

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

Eine andere Möglichkeit ist, sich den Indexer anzusehen:

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

Verwenden neuer TypeInfo:

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

Mit der folgenden Erweiterungsmethode können Sie ohne Reflexion davonkommen:

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

Oder allgemeiner:

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

Verwendungszweck:

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

Versuchen

list.GetType().GetGenericArguments()

Das ist Arbeit für mich. Wo myList eine unbekannte Art von Liste ist.

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

Wenn Sie nicht die gesamte Typvariable benötigen und nur den Typ überprüfen möchten, können Sie einfach eine temporäre Variable erstellen und den Operator is verwenden.

T checkType = default(T);

if (checkType is MyClass)
{}

Sie können diese für den Rückgabetyp einer generischen Liste verwenden:

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

Bedenken Sie Folgendes: Ich verwende es, um 20 typisierte Listen auf dieselbe Weise zu exportieren:

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

Ich benutze diese Erweiterungsmethode, um etwas Ähnliches zu erreichen:

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

Sie verwenden es so:

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

Dies ist nicht ganz das, wonach Sie suchen, aber es ist hilfreich, um die beteiligten Techniken zu demonstrieren.

Die GetGenericArgument()Methode muss für den Basistyp Ihrer Instanz festgelegt werden (deren Klasse eine generische Klasse ist myClass<T>). Andernfalls wird ein Typ [0] zurückgegeben.

Beispiel:

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

Sie können den Typ "T" von jedem Sammlungstyp abrufen, der IEnumerable <T> wie folgt implementiert:

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

Beachten Sie, dass Sammlungstypen, die IEnumerable <T> zweimal implementieren, nicht unterstützt werden, z

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

Ich nehme an, Sie könnten eine Reihe von Typen zurückgeben, wenn Sie dies unterstützen müssten ...

Außerdem möchten Sie möglicherweise auch das Ergebnis pro Sammlungstyp zwischenspeichern, wenn Sie dies häufig tun (z. B. in einer Schleife).

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

Verwenden der Lösung von 3dGrabber:

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

//and now 

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

Wenn Sie den zugrunde liegenden Typ einer Eigenschaft kennen möchten, versuchen Sie Folgendes:

propInfo.PropertyType.UnderlyingSystemType.GenericTypeArguments[0]

So habe ich es gemacht

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

Dann nenne es so

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

ODER

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

Art:

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