Làm thế nào để có được loại T từ một thành viên của một lớp hoặc phương thức chung?

Giả sử tôi có một thành viên chung trong một lớp hoặc phương thức, vì vậy:

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

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

Khi tôi khởi tạo lớp, Ttrở thành MyTypeObject1, vì vậy lớp có thuộc tính danh sách chung : List<MyTypeObject1>. Điều tương tự cũng áp dụng cho một phương thức chung trong một lớp không chung chung:

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

        // get type of T
    }
}

Tôi muốn biết, danh sách các lớp của tôi chứa loại đối tượng nào. Vậy thuộc tính danh sách được gọi Barhoặc biến cục bộ baz, chứa loại Tnào?

Tôi không thể làm được Bar[0].GetType(), vì danh sách có thể chứa các phần tử bằng không. Tôi làm nó như thế nào?

Nếu tôi hiểu chính xác, danh sách của bạn có cùng tham số loại với chính lớp chứa. Nếu đây là trường hợp, thì:

Type typeParameterType = typeof(T);

Nếu bạn đang ở trong tình huống may mắn có được objectmột tham số loại, hãy xem câu trả lời của Marc .

(lưu ý: Tôi giả định rằng tất cả các bạn biết là objecthay IListhoặc tương tự, và rằng danh sách này có thể là bất kỳ loại tại thời gian chạy)

Nếu bạn biết đó là một List<T>, thì:

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

Một lựa chọn khác là nhìn vào bộ chỉ mục:

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

Sử dụng TypeInfo mới:

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

Với phương pháp mở rộng sau đây, bạn có thể thoát khỏi mà không cần phản ánh:

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

Hay nói chung hơn:

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

Sử dụng:

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

Thử

list.GetType().GetGenericArguments()

Đó là công việc cho tôi. Trong đó myList là một số loại danh sách chưa biết.

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

Nếu bạn không cần toàn bộ biến Loại và chỉ muốn kiểm tra loại bạn có thể dễ dàng tạo biến tạm thời và sử dụng là toán tử.

T checkType = default(T);

if (checkType is MyClass)
{}

Bạn có thể sử dụng loại này cho loại trả về của danh sách chung:

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

Xem xét điều này: Tôi sử dụng nó để xuất danh sách 20 gõ theo cùng một cách:

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

Tôi sử dụng phương pháp mở rộng này để thực hiện một cái gì đó tương tự:

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

Bạn sử dụng nó như thế này:

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

Đây không hoàn toàn là những gì bạn đang tìm kiếm, nhưng nó hữu ích trong việc thể hiện các kỹ thuật liên quan.

Các GetGenericArgument()phương pháp này phải được thiết lập trên cơ sở Loại sơ thẩm của bạn (có lớp là một lớp generic myClass<T>). Mặt khác, nó trả về một loại [0]

Thí dụ:

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

Bạn có thể lấy loại "T" từ bất kỳ loại bộ sưu tập nào thực hiện IEnumerable <T> với các mục sau:

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

Lưu ý rằng nó không hỗ trợ các loại bộ sưu tập triển khai IEn Countable <T> hai lần, ví dụ:

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

Tôi cho rằng bạn có thể trả về một loạt các loại nếu bạn cần hỗ trợ ...

Ngoài ra, bạn cũng có thể muốn lưu trữ kết quả cho mỗi loại bộ sưu tập nếu bạn thực hiện việc này rất nhiều (ví dụ: trong một vòng lặp).

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

Sử dụng giải pháp của 3dGrabber:

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

//and now 

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

Nếu bạn muốn biết loại cơ bản của một tài sản, hãy thử điều này:

propInfo.PropertyType.UnderlyingSystemType.GenericTypeArguments[0]

Đây là cách tôi đã làm nó

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

Sau đó gọi nó như thế này

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

HOẶC LÀ

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

Kiểu:

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