วิธีการตรวจสอบว่าชนิดที่ใช้อินเทอร์เฟซกับ C # สะท้อน

ไม่สะท้อนในC#ทางที่เป็นข้อเสนอเพื่อตรวจสอบว่าได้รับบางSystem.Typeรุ่นประเภทอินเตอร์เฟซบางอย่าง?

public interface IMyInterface {}

public class MyType : IMyInterface {}

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

คุณมีตัวเลือกน้อย:

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

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

สำหรับอินเตอร์เฟสทั่วไปมันแตกต่างกันเล็กน้อย

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

การใช้Type.IsAssignableFrom:

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

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

หรือ

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

ฉันคิดว่านี่เป็นรุ่นที่ถูกต้องด้วยเหตุผลสามประการ:

1. มันใช้ GetInterfaces และไม่ใช่ IsAssignableFrom มันเร็วกว่าเนื่องจาก IsAssignableFrom ในที่สุดหลังจากการตรวจสอบหลายครั้งเรียก GetInterfaces
2. มันวนซ้ำอาร์เรย์โลคัลดังนั้นจะไม่มีการตรวจสอบขอบเขต
3. มันใช้ตัวดำเนินการ == ซึ่งกำหนดไว้สำหรับ Type ดังนั้นอาจปลอดภัยกว่าเมธอด Equals (ซึ่งการเรียกประกอบด้วยจะใช้ในที่สุด)

ฉันเพิ่งทำ:

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

ฉันหวังว่าฉันจะได้พูดwhere I : interfaceแต่interfaceไม่ใช่ตัวเลือกข้อ จำกัด พารามิเตอร์ทั่วไป classใกล้เคียงที่สุดเท่าที่จะได้รับ

การใช้งาน:

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

ฉันเพิ่งพูดImplementsเพราะมันใช้งานง่ายกว่า ฉันIsAssignableFromพลิกตัวตลอดเวลา

การแก้ไขคำตอบของ Jeff เพื่อประสิทธิภาพที่ดีที่สุด (ขอบคุณการทดสอบประสิทธิภาพโดย Pierre Arnaud):

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

เพื่อค้นหาทุกชนิดที่ใช้อินเตอร์เฟซในการที่ได้รับAssembly:

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

อย่างที่คนอื่นพูดถึงแล้ว: เบนจามิน 10 เม.ย. 56 เวลา 22:21 น. "

มันแน่ใจว่าเป็นเรื่องง่ายที่จะไม่ใส่ใจและรับอาร์กิวเมนต์สำหรับ IsAssignable จากข้างหลัง ฉันจะไปกับ GetInterfaces ทันที: p -

อีกวิธีคือการสร้างวิธีการขยายสั้น ๆ ที่ตอบสนองวิธีคิดที่ "ปกติ" (และตกลงกันว่านี่เป็นทางเลือกส่วนตัวเล็กน้อยที่จะทำให้มัน "เป็นธรรมชาติมากขึ้น" ตามความชอบ ):

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

และทำไมไม่ไปที่กว้างกว่านี้อีกสักหน่อย (ก็ไม่แน่ใจว่ามันน่าสนใจจริง ๆ หรือเปล่าฉันว่าฉันแค่ผ่านการซินแทรค 'น้ำตาล')

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

ฉันคิดว่ามันอาจจะดูเป็นธรรมชาติมากกว่าเดิม แต่อีกครั้งแค่เรื่องความคิดเห็นส่วนตัว:

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

หากคุณมีประเภทหรืออินสแตนซ์คุณสามารถตรวจสอบได้อย่างง่ายดายว่าพวกเขาสนับสนุนอินเทอร์เฟซเฉพาะ

วิธีทดสอบว่าวัตถุใช้ส่วนต่อประสานที่แน่นอนหรือไม่:

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

วิธีทดสอบว่าใช้อินเทอร์เฟซที่แน่นอนได้หรือไม่:

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

หากคุณมีอ็อบเจกต์สามัญและต้องการที่จะทำการแคสต์รวมถึงการตรวจสอบว่าอินเตอร์เฟสที่คุณแคสต์นั้นถูกนำไปใช้งานหรือไม่รหัสคือ:

 var myCastedObject = myObject as IMyInterface;

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

IsAssignableFromถูกย้ายไปที่TypeInfo:

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

ทุกคนที่ค้นหาสิ่งนี้อาจพบว่าวิธีการต่อไปนี้มีประโยชน์:

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

การทดสอบ 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);
    }
}

เกี่ยวกับอะไร

if(MyType as IMyInterface != null)

?

เกี่ยวกับอะไร

typeof(IWhatever).GetTypeInfo().IsInterface

คำตอบที่ถูกต้องคือ

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

อย่างไรก็ตาม

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

อาจส่งคืนผลลัพธ์ที่ผิดเนื่องจากโค้ดต่อไปนี้แสดงด้วยสตริงและ 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}");
    }

ผล:

 isConvertibleDirect: True
 isConvertibleTypeAssignable: False
 isConvertibleHasInterface: True

โปรดทราบว่าหากคุณมีอินเทอร์เฟซทั่วไปIMyInterface<T>สิ่งนี้จะส่งคืนเสมอfalse:

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

สิ่งนี้ไม่ทำงาน:

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

อย่างไรก็ตามหากMyTypeใช้IMyInterface<MyType>งานได้และส่งคืนtrue:

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

แต่คุณอาจจะไม่ทราบว่าพารามิเตอร์ชนิดTที่รันไทม์ ทางออกที่ค่อนข้างแฮ็คคือ:

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

วิธีการแก้ปัญหาของเจฟฟ์แฮ็คน้อยลงเล็กน้อย:

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

นี่คือวิธีการขยายTypeที่เหมาะกับกรณีใด ๆ :

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

(โปรดทราบว่าข้างต้นใช้ linq ซึ่งอาจช้ากว่าลูป)

จากนั้นคุณสามารถทำได้:

   typeof(MyType).IsImplementing(IMyInterface<>)