Wie erhält man den Typ von T von einem Mitglied einer generischen Klasse oder Methode?

Question

Nehmen wir an, ich habe ein generisches Mitglied in einer Klasse oder Methode, etwa so:

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

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

Wenn ich die Klasse instanziere, wird die T wird MyTypeObject1 Die Klasse hat also eine generische Listeneigenschaft: List<MyTypeObject1> . Dasselbe 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. Also welche Art von T wird die Listeneigenschaft namens Bar oder die lokale Variable baz enthalten?

Ich kann nicht tun Bar[0].GetType() , da die Liste auch Nullelemente enthalten kann. Wie kann ich das tun?

Answer 1

Bei mir funktioniert das Folgende. Wobei myList eine unbekannte Art von Liste ist.

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

Answer 2

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

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

Answer 3

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

Ejemplo:

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

Answer 4

Bedenken Sie dies:

Ich verwende es, um 20 getippte Listen auf die gleiche 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);
    }
}

Answer 5

Ich verwende 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>>");
}

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