Bagaimana cara mendapatkan tipe T dari anggota kelas umum atau metode?

Katakanlah saya memiliki anggota generik di kelas atau metode, jadi:

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

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

Ketika saya instantiate kelas, Tmenjadi MyTypeObject1, sehingga kelas memiliki properti daftar generik: List<MyTypeObject1>. Hal yang sama berlaku untuk metode generik di kelas non-generik:

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

        // get type of T
    }
}

Saya ingin tahu, jenis objek apa yang terdapat dalam daftar kelas saya. Jadi daftar properti yang dipanggil Baratau variabel lokal baz, berisi jenis apa T?

Saya tidak bisa melakukannya Bar[0].GetType(), karena daftar mungkin berisi elemen nol. Bagaimana saya bisa melakukannya?

Jika saya mengerti dengan benar, daftar Anda memiliki parameter tipe yang sama dengan kelas kontainer itu sendiri. Jika ini masalahnya, maka:

Type typeParameterType = typeof(T);

Jika Anda berada dalam situasi beruntung memiliki objectsebagai parameter tipe, lihat jawaban Marc .

(catatan: Saya berasumsi bahwa yang Anda tahu adalah objectatauIList atau serupa, dan bahwa daftar bisa menjadi semua jenis saat runtime)

Jika Anda tahu itu adalah List<T>, maka:

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

Pilihan lain adalah melihat pengindeks:

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

Menggunakan TypeInfo baru:

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

Dengan metode ekstensi berikut, Anda dapat keluar tanpa refleksi:

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

Atau lebih umum:

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

Pemakaian:

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

Mencoba

list.GetType().GetGenericArguments()

Itu bekerja untuk saya. Di mana myList adalah semacam daftar yang tidak diketahui.

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

Jika Anda tidak memerlukan variabel Type keseluruhan dan hanya ingin memeriksa tipe Anda dapat dengan mudah membuat variabel temp dan gunakan operator.

T checkType = default(T);

if (checkType is MyClass)
{}

Anda dapat menggunakan yang ini untuk jenis kembali daftar umum:

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

Pertimbangkan ini: Saya menggunakannya untuk mengekspor 20 daftar yang diketik dengan cara yang sama:

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

Saya menggunakan metode ekstensi ini untuk mencapai sesuatu yang serupa:

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

Anda menggunakannya seperti ini:

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

Ini bukan yang Anda cari, tetapi sangat membantu dalam menunjukkan teknik yang terlibat.

The GetGenericArgument()Metode harus diatur pada Basis Jenis Misalnya Anda (yang kelasnya adalah kelas generikmyClass<T> ). Jika tidak, ia mengembalikan suatu tipe [0]

Contoh:

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

Anda bisa mendapatkan jenis "T" dari semua jenis koleksi yang mengimplementasikan IEnumerable <T> dengan yang berikut:

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

Perhatikan bahwa itu tidak mendukung tipe pengumpulan yang mengimplementasikan IEnumerable <T> dua kali, misalnya

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

Saya kira Anda dapat mengembalikan berbagai jenis jika Anda perlu mendukung ini ...

Selain itu, Anda mungkin juga ingin men-cache hasil per jenis koleksi jika Anda sering melakukan ini (misalnya dalam satu lingkaran).

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

Menggunakan solusi 3dGrabber:

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

//and now 

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

Jika Anda ingin mengetahui jenis yang mendasari properti, coba ini:

propInfo.PropertyType.UnderlyingSystemType.GenericTypeArguments[0]

Beginilah cara saya melakukannya

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

Lalu panggil seperti ini

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

ATAU

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

Tipe:

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