Cách xác định xem một loại có thực hiện giao diện với phản chiếu C # không

Liệu sự phản chiếu trong C#cung cấp một cách để xác định nếu một số System.Typeloại mô hình nhất định một số giao diện?

public interface IMyInterface {}

public class MyType : IMyInterface {}

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

Bạn có một vài lựa chọn:

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

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

Đối với một giao diện chung, nó hơi khác một chút.

typeof(MyType).GetInterfaces().Any(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IMyInterface<>))

Sử dụng Type.IsAssignableFrom:

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

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

hoặc là

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

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à bản phát hành chính xác, vì ba lý do:

1. Nó sử dụng GetInterfaces chứ không phải IsAssignableFrom, nó nhanh hơn kể từ IsAssignableFrom sau khi một số kiểm tra gọi GetInterfaces.
2. Nó lặp lại trên 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 xác định cho Loại, vì vậy có lẽ an toàn hơn phương thức Equals (mà cuộc gọi Chứa, cuối cùng sẽ sử dụng).

Tôi vừa làm:

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

Tôi ước tôi có thể nói where I : interface, nhưng interfacekhông phải là một tùy chọn ràng buộc tham số chung.classlà gần như nó được.

Sử dụng:

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

Tôi chỉ nói Implementsvì điều đó trực quan hơn. Tôi luôn luôn bị IsAssignableFromlật.

Sửa đổi câu trả lời của Jeff để có 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 thực hiện một giao diện trong một cho trước Assembly:

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

Như một người khác đã đề cập: Benjamin 10 tháng 4 '13 lúc 22:21 "

Thật dễ dàng để không chú ý và nhận được các đối số cho IsAssignableFrom ngược. Tôi sẽ đi với GetInterfaces ngay bây giờ: p -

Vâng, một cách khác là chỉ tạo ra một phương pháp mở rộng ngắn, đáp ứng, ở một mức độ nào đó, cách suy nghĩ "thông thường nhất" (và đồng ý đây là một lựa chọn cá nhân rất ít để 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 TypeExtensions
{
    public static bool IsAssignableTo(this Type type, Type assignableType)
    {
        return assignableType.IsAssignableFrom(type);
    }
}

Và tại sao không nói chung chung hơn một chút (cũng không chắc nó có thực sự thú vị không, tôi cho rằng tôi chỉ đang vượt qua một nhúm đường 'cú pháp' khác):

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

    public static bool IsAssignableTo<TAssignable>(this Type type)
    {
        return IsAssignableTo(type, typeof(TAssignable));
    }
}

Tôi nghĩ rằng nó có thể tự nhiên hơn nhiều 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>();

Nếu bạn có một loại hoặc một thể hiện, bạn có thể dễ dàng kiểm tra xem chúng có hỗ trợ một giao diện cụ thể không.

Để kiểm tra nếu một đối tượng thực hiện một giao diện nhất định:

if(myObject is IMyInterface) {
  // object myObject implements IMyInterface
}

Để kiểm tra nếu một loại thực hiện một giao diện nhất định:

if(typeof(IMyInterface).IsAssignableFrom(typeof(MyType))) {
  // type MyType implements IMyInterface
}

Nếu bạn có một đối tượng chung và muốn thực hiện phân vai cũng như kiểm tra xem giao diện bạn truyền tới có được thực thi mã không:

 var myCastedObject = myObject as IMyInterface;

    if(myCastedObject != null) {
      // object myObject implements IMyInterface
    }

IsAssignableFromhiện được chuyển đến TypeInfo:

typeof(ISMSRequest).GetTypeInfo().IsAssignableFrom(typeof(T).GetTypeInfo());

Bất cứ ai tìm kiếm điều này có thể thấy phương pháp mở rộng sau đây hữu ích:

public static class TypeExtensions
{
    public static bool ImplementsInterface(this Type type, Type @interface)
    {
        if (type == null)
        {
            throw new ArgumentNullException(nameof(type));
        }

        if (@interface == null)
        {
            throw new ArgumentNullException(nameof(@interface));
        }

        var interfaces = type.GetInterfaces();
        if (@interface.IsGenericTypeDefinition)
        {
            foreach (var item in interfaces)
            {
                if (item.IsConstructedGenericType && item.GetGenericTypeDefinition() == @interface)
                {
                    return true;
                }
            }
        }
        else
        {
            foreach (var item in interfaces)
            {
                if (item == @interface)
                {
                    return true;
                }
            }
        }

        return false;
    }
}

xét nghiệm xunit:

public class TypeExtensionTests
{
    [Theory]
    [InlineData(typeof(string), typeof(IList<int>), false)]
    [InlineData(typeof(List<>), typeof(IList<int>), false)]
    [InlineData(typeof(List<>), typeof(IList<>), true)]
    [InlineData(typeof(List<int>), typeof(IList<>), true)]
    [InlineData(typeof(List<int>), typeof(IList<int>), true)]
    [InlineData(typeof(List<int>), typeof(IList<string>), false)]
    public void ValidateTypeImplementsInterface(Type type, Type @interface, bool expect)
    {
        var output = type.ImplementsInterface(@interface);
        Assert.Equal(expect, output);
    }
}

Thế còn

if(MyType as IMyInterface != null)

?

Thế còn

typeof(IWhatever).GetTypeInfo().IsInterface

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ề kết quả sai, vì đoạn mã sau hiển thị 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}");
    }

Các kết quả:

 isConvertibleDirect: True
 isConvertibleTypeAssignable: False
 isConvertibleHasInterface: True

Lưu ý rằng nếu bạn có một giao diện chung IMyInterface<T>thì điều này sẽ luôn trả về false:

  typeof(IMyInterface<>).IsAssignableFrom(typeof(MyType)) /* ALWAYS FALSE */

Điều này cũng không hoạt động:

  typeof(MyType).GetInterfaces().Contains(typeof(IMyInterface<>))  /* ALWAYS FALSE */

Tuy nhiên, nếu MyTypethực hiện IMyInterface<MyType>điều này hoạt động và trả về true:

  typeof(IMyInterface<MyType>).IsAssignableFrom(typeof(MyType))

Tuy nhiên, bạn có thể sẽ không biết tham số loại Tkhi chạy . Một giải pháp hơi khó là:

  typeof(MyType).GetInterfaces()
                .Any(x=>x.Name == typeof(IMyInterface<>).Name)

Giải pháp của Jeff là một chút ít hacky:

  typeof(MyType).GetInterfaces()
         .Any(i => i.IsGenericType 
             && i.GetGenericTypeDefinition() == typeof(IMyInterface<>));

Đây là một phương pháp mở rộng trên Typeđó hoạt động cho mọi trường hợp:

public static class TypeExtensions
{
    public static bool IsImplementing(this Type type, Type someInterface)
    {
        return type.GetInterfaces()
             .Any(i => i == someInterface 
                 || i.IsGenericType 
                    && i.GetGenericTypeDefinition() == someInterface);
    }
}

(Lưu ý rằng ở trên sử dụng linq, có thể chậm hơn vòng lặp.)

Sau đó bạn có thể làm:

   typeof(MyType).IsImplementing(IMyInterface<>)