Làm thế nào tôi có thể nhìn thấy nếu GenericTypeDefinition triển khai IEnumerable <>

Question

Tôi có một phương pháp kiểm tra nếu một loại là chung chung và sau đó kiểm tra nếu GenericTypeDefinition là IEnumerable<>.

static Type GetEnumerableType(Type type) 
{ 
    if(type.IsGenericType) { 
     var genericTypeDefinition = type.GetGenericTypeDefinition(); 
     if (genericTypeDefinition == typeof(IEnumerable<>)) { 
      return type.GetGenericArguments()[0]; 
     } 
    } 
    return null; 
} 

Hoạt động như một nét duyên dáng nếu nó là IEnumerable. Nếu GenericTypeDefinition là IList<> hoặc List<> thì nó không hoạt động. Tôi đã thử ..

typeof(IEnumerable<>).IsAssignableFrom(genericTypeDefinition) 

..không thành công. Tất nhiên phải có một cách tốt hơn sau đó chuỗi khác tuyên bố?

Answer 1

Bạn có thể sử dụng GetInterfaces để kiểm tra xem một loại thực IEnumerable<> như vậy

Type type = new List<string>().GetType(); 

if (type.IsGenericType) 
{ 
    var genericTypeDefinition = type.GetGenericTypeDefinition(); 

    if (genericTypeDefinition.GetInterfaces() 
       .Any(t => t.IsGenericType && 
          t.GetGenericTypeDefinition() == typeof(IEnumerable<>))) 
    { 
     return type.GetGenericArguments()[0]; 
    } 
} 

Answer 2

Tôi đã kết thúc việc tìm hiểu sâu hơn về xử lý đối tượng chung và thấy cách này phức tạp hơn bất kỳ giả định ban đầu nào. Đây là phương pháp bây giờ tôi đang sử dụng:

/// <summary>Check whether the specified type is enumerable.</summary> 
/// <param name="type">The type.</param> 
/// <param name="underlyingType">IEnumerable{int} would be int</param> 
/// <param name="excludeString"> 
/// [OPTIONAL] if set to <c>true</c> [exclude string]. Strings are enumerable as char[] 
/// this is likely not something you want. Default is true (string will return false) 
/// </param> 
/// <returns><c>true</c> supplied type is enumerable otherwise <c>false</c></returns> 
public static bool IsEnumerable(this Type type, out Type underlyingType, 
           bool excludeString = true) 
{ 
    underlyingType = null; 

    if (type.IsEnum || type.IsPrimitive || type.IsValueType) return false; 

    if (excludeString && type == typeof(string)) return false; 

    if (type.IsGenericType) 
    { 
     if (type.IsTypeDefinitionEnumerable() || 
      type.GetInterfaces() 
       .Any(t => t.IsSelfEnumerable() || t.IsTypeDefinitionEnumerable())) 
     { 
      underlyingType = type.GetGenericArguments()[0]; 
      return true; 
     } 
    } 
    //direct implementations of IEnumerable<T>, inheritance from List<T> etc 
    var enumerableOrNull = type.GetInterfaces() 
           .FirstOrDefault(t => t.IsTypeDefinitionEnumerable()); 
    if (enumerableOrNull == null) return false; 

    underlyingType = enumerableOrNull.GetGenericArguments()[0]; 
    return true; 
} 

//

private static bool IsSelfEnumerable(this Type type) 
{ 
    bool isDirectly = type == typeof(IEnumerable<>); 
    return isDirectly; 
} 

private static bool IsTypeDefinitionEnumerable(this Type type) 
{ 
    bool isViaInterfaces = type.IsGenericType && 
          type.GetGenericTypeDefinition().IsSelfEnumerable(); 
    return isViaInterfaces; 
} 

Giải pháp này được thử nghiệm:

Install-Package NUnit -version 2.6.4

Gói cài đặt nên

[Test] 
public void List_is_enumerable() 
{ 
    var sut = new List<int>(); 

    Type underlyingType; 
    var result = sut.IsEnumerable(out underlyingType); 

    result.ShouldBeTrue(); 
    underlyingType.ShouldBe(typeof(int)); 
} 

//

[Test] 
public void Yield_return_is_enumerable() 
{ 
    var sut = Yielded(); 

    Type underlyingType; 
    var result = sut.IsEnumerable(out underlyingType); 

    result.ShouldBeTrue(); 
    underlyingType.ShouldBe(typeof(int)); 
} 

private IEnumerable<int> Yielded() 
{ 
    for (int i = 0; i < 3; i++) 
    { 
     yield return i; 
    } 
} 

//

[Test] 
public void int_is_not_an_enumerable() 
{ 
    var sut = 5; 

    Type underlyingType; 
    var result = sut.IsEnumerable(out underlyingType); 

    result.ShouldBe(false); 
    underlyingType.ShouldBeNull(); 
} 

[Test] 
public void object_is_not_an_enumerable() 
{ 
    var sut = new { foo = 1}; 

    Type underlyingType; 
    var result = sut.IsEnumerable(out underlyingType); 

    result.ShouldBe(false); 
    underlyingType.ShouldBeNull(); 
} 

---

giữ cho hậu thế. Điều này không trả lời câu hỏi ban đầu nhưng rõ ràng là hữu ích cho các thành viên ở đây.

public static bool IsA<T>(this Type type) 
{ 
    return typeof (T).IsAssignableFrom(type); 
}