Cách xác định xem một loại có thực hiện giao diện với C# reflection

Question

Có phải phản ánh trong C# cung cấp cách xác định xem một số giao diện nào có một số giao diện không?

public interface IMyInterface {} 

public class MyType : IMyInterface {} 

// should yield 'true' 
typeof(MyType)./* ????? */MODELS_INTERFACE(IMyInterface); 

Answer 1

Bạn có một vài lựa chọn ra khỏi đỉnh đầu của tôi

1. typeof(IMyInterface).IsAssignableFrom(typeof(MyType))

2. typeof(MyType).GetInterfaces().Contains(typeof(IMyInterface))

Answer 2

Sử dụng Type.IsAssignableFrom:

typeof(IMyInterface).IsAssignableFrom(typeof(MyType)); 

Answer 3

typeof(IMyInterface).IsAssignableFrom(someclass.GetType()); 

hoặc

typeof(IMyInterface).IsAssignableFrom(typeof(MyType)); 

Answer 4

public static bool ImplementsInterface(this Type type, Type ifaceType) { 
     Type[] intf = type.GetInterfaces(); 
     for (int i = 0; i < intf.Length; i++) { 
      if (intf[ i ] == ifaceType) { 
       return true; 
      } 
     } 
     return false; 
    } 

Tôi nghĩ rằng đây là phiên bản đúng, vì ba lý do:

1) Nó sử dụng getInterfaces và không IsAssignableFrom, nó nhanh hơn kể từ IsAssignableFrom cuối cùng sau một số kiểm tra không gọi GetInterfaces.
2) Nó lặp qua mảng cục bộ, do đó sẽ không có kiểm tra giới hạn.
3) Nó sử dụng toán tử == được định nghĩa cho Type, vì vậy có lẽ an toàn hơn phương thức Equals (có chứa cuộc gọi, cuối cùng sẽ sử dụng).

Answer 5

Khi ai đó đã đề cập: Benjamin 10 Tháng 4 '13 tại 22:21"

Nó chắc chắn là dễ dàng để không chú ý và nhận được những lập luận cho IsAssignableFrom ngược.Tôi sẽ đi với GetInterfaces ngay bây giờ: p -

Vâng, một cách khác chỉ là tạo ra một phương pháp mở rộng ngắn đáp ứng, một cách nào đó, cách suy nghĩ "thông thường nhất" (và đồng ý đây là ít sự lựa chọn cá nhân để làm cho nó hơi "tự nhiên hơn" dựa trên sở thích của một người):

public static class TypeHelpers 
{ 
    public static Boolean IsAssignableTo(Type type, Type assignableType) 
    { 
     return assignableType.IsAssignableFrom(type); 
    } 
} 

public static class TypeExtensions 
{ 
    public static Boolean IsAssignableTo(this Type type, Type assignableType) 
    { 
     return TypeHelpers.IsAssignableTo(type, assignableType); 
    } 
} 

Và tại sao không đi chung chung hơn một chút (cũng không chắc chắn nếu nó thực sự là thú vị, tôi cũng giả định tôi chỉ chuyển một đoạn đường 'cú pháp' khác):

public static class TypeHelpers 
{ 
    public static Boolean IsAssignableTo(Type type, Type assignableType) 
    { 
     return assignableType.IsAssignableFrom(type); 
    } 

    public static Boolean IsAssignableTo<TAssignable>(Type type) 
    { 
     return TypeHelpers.IsAssignableTo(type, typeof(TAssignable)); 
    } 
} 

public static class TypeExtensions 
{ 
    public static Boolean IsAssignableTo(this Type type, Type assignableType) 
    { 
     return TypeHelpers.IsAssignableTo(type, assignableType); 
    } 

    public static Boolean IsAssignableTo<TAssignable>(this Type type) 
    { 
     return TypeHelpers.IsAssignableTo<TAssignable>(type); 
    } 
} 

Tôi nghĩ rằng nó có thể là tự nhiên nhiều hơn nữa theo cách đó, nhưng một lần nữa chỉ là vấn đề của những ý kiến ​​rất cá nhân:

var isTrue = michelleType.IsAssignableTo<IMaBelle>(); 

Answer 6

câu trả lời

Sửa Jeff cho hiệu suất tối ưu (nhờ kiểm tra hiệu suất của Pierre Arnaud):

var type = typeof(MyType); 
var implementsInterface = typeof(IMyInterface).IsAssignableFrom(type) && type.IsClass; 

Để tìm tất cả các loại mà thực hiện một giao diện trong một Assembly đưa ra:

var implementations = typeof(TypeInTargetAssembly).Assembly.GetTypes() 
          .Where(t => typeof(IMyInterface).IsAssignableFrom(t) && t.IsClass); 

Answer 7

gì abou t

if(MyType as IMyInterface != null) 

?

Answer 8

gì về

typeof(IWhatever).GetTypeInfo().IsInterface 

Answer 9

tôi chỉ làm:

public static bool Implements<I>(this Type source) where I : class 
{ 
    return typeof(I).IsAssignableFrom(source); 
} 

Tôi ước gì tôi có thể nói where I : interface, nhưng interface không phải là một lựa chọn tham số hạn chế chung. class là gần như nó được.

Cách sử dụng:

if(MyType.Implements<IInitializable>()) 
    MyCollection.Initialize(); 

Tôi chỉ nói Implements bởi vì đó là trực quan hơn. Tôi luôn nhận được IsAssignableFrom bị lật.

Answer 10

IsAssignableFrom hiện đang chuyển sang TypeInfo vậy .... typeof (ISMSRequest) .GetTypeInfo(). IsAssignableFrom (typeof (T) .GetTypeInfo())

Answer 11

Một câu trả lời đúng là

typeof(MyType).GetInterface(nameof(IMyInterface)) != null; 

Tuy nhiên,

typeof(MyType).IsAssignableFrom(typeof(IMyInterface)); 

có thể trả về một kết quả sai, vì mã sau đây cho thấy với chuỗi và IConvertible:

static void TestIConvertible() 
    { 
     string test = "test"; 
     Type stringType = typeof(string); // or test.GetType(); 

     bool isConvertibleDirect = test is IConvertible; 
     bool isConvertibleTypeAssignable = stringType.IsAssignableFrom(typeof(IConvertible)); 
     bool isConvertibleHasInterface = stringType.GetInterface(nameof(IConvertible)) != null; 

     Console.WriteLine($"isConvertibleDirect: {isConvertibleDirect}"); 
     Console.WriteLine($"isConvertibleTypeAssignable: {isConvertibleTypeAssignable}"); 
     Console.WriteLine($"isConvertibleHasInterface: {isConvertibleHasInterface}"); 
    } 

Kết quả:

isConvertibleDirect: True 
isConvertibleTypeAssignable: False 
isConvertibleHasInterface: True