제네릭 클래스 또는 메서드의 멤버에서 T 유형을 얻는 방법은 무엇입니까?

클래스 또는 메서드에 일반 멤버가 있다고 가정 해 보겠습니다.

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

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

나는 클래스를 인스턴스화 할 때이 T되고 MyTypeObject1, 그래서 클래스는 일반적인 목록 속성이 있습니다 List<MyTypeObject1>. 일반이 아닌 클래스의 일반 메소드에도 동일하게 적용됩니다.

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

        // get type of T
    }
}

클래스 목록에 어떤 유형의 객체가 포함되어 있는지 알고 싶습니다. 따라서 호출 된 목록 속성 Bar또는 로컬 변수 baz에는 어떤 유형의 T?

Bar[0].GetType()목록에 0 요소가 포함될 수 있기 때문에 할 수 없습니다 . 어떻게하니?

올바르게 이해하면 목록에 컨테이너 클래스 자체와 동일한 유형 매개 변수가 있습니다. 이 경우에는 다음을 수행하십시오.

Type typeParameterType = typeof(T);

운 좋게도 objecttype 매개 변수로 사용하는 경우 Marc의 답변을 참조하십시오 .

(참고 : 나는 당신이 아는 모든 것이 object또는IList 또는 유사한하고 목록이 실행시에 모든 유형이 될 수 있음)

당신이 그것을 알고 있다면 List<T>:

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

또 다른 옵션은 인덱서를 보는 것입니다.

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

새로운 TypeInfo 사용하기 :

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

다음 확장 방법을 사용하면 리플렉션없이 벗어날 수 있습니다.

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

또는 더 일반적인 :

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

용법:

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

시험

list.GetType().GetGenericArguments()

그것은 나를 위해 일한 것입니다. 여기서 myList는 알 수없는 종류의 목록입니다.

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

전체 Type 변수가 필요하지 않고 유형을 확인하려는 경우 임시 변수를 쉽게 만들 수 있으며 연산자는 연산자입니다.

T checkType = default(T);

if (checkType is MyClass)
{}

이 유형을 일반 유형의 리턴 유형으로 사용할 수 있습니다.

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

이것을 고려하십시오 : 나는 그것을 같은 방식으로 20 유형 목록을 내보내는 데 사용합니다 :

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

나는이 확장 방법을 사용하여 비슷한 것을 성취합니다.

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

다음과 같이 사용하십시오.

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

이것은 당신이 찾고있는 것이 아니지만 관련 기술을 시연하는 데 도움이됩니다.

그만큼 GetGenericArgument()메소드는 클래스 일반적인 클래스 인스턴스의 기본 유형 (설정해야합니다myClass<T> ). 그렇지 않으면, 타입을 돌려 준다 [0]

예:

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

다음과 같이 IEnumerable <T>를 구현하는 모든 컬렉션 유형에서 "T"유형을 얻을 수 있습니다.

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

IEnumerable <T>를 두 번 구현하는 컬렉션 유형은 지원하지 않습니다. 예 :

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

이것을 지원 해야하는 경우 유형 배열을 반환 할 수 있다고 가정합니다 ...

또한이 작업을 많이 수행하는 경우 (예 : 루프) 컬렉션 유형별로 결과를 캐시 할 수도 있습니다.

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

3dGrabber의 솔루션 사용 :

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

//and now 

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

속성의 기본 유형을 알고 싶다면 다음을 시도하십시오.

propInfo.PropertyType.UnderlyingSystemType.GenericTypeArguments[0]

이것이 내가 한 방법입니다

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

그럼 이렇게 불러

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

또는

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

유형:

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