确定一个类是否实现了一个非常特定的接口

Question

关于这个话题有很多问题，但我有一个稍微改变了它的版本。

我们有以下代码：

interface IFoo { } 
interface IBar : IFoo { } 
class Foo : IFoo { } 
class Bar : IBar { } 

bool Implements_IFoo(Type type) { /* ??? */ } 

现在，故事的扭曲：方法Implements_IFoo应该只在类型，而不是实现的IFoo任何从IFoo的派生的接口返回true。为了说明这里是这种方法的一些例子：

Implements_IFoo(typeof(Foo)); // Should return true 

Implements_IFoo(typeof(Bar)); // Should return false as Bar type 
           // implements an interface derived from IFoo 

注意，有可能从IFoo的衍生大量的接口和你不一定知道它们的存在。

显而易见的方法是通过反射找到从IFoo派生的所有接口，然后检查typeof（Bar）.GetInterfaces（）是其中的任何接口。但我想知道是否有人可以想出更优雅的解决方案。

PS这个问题来自我发现的一些代码，它使用这个检查类（if(obj.GetType() == typeof(BaseClass)) { ... }）。我们正在使用现在特定代码的接口替换类。此外，为了以防万一 - 我将此检查作为布尔标志实施，所以此问题纯粹是假设性的。

Answer 1

我进行了尝试，因为它听上去很不错，这一点也适用于你的例子：

bool ImplementsIFooDirectly(Type t) { 
    if (t.BaseType != null && ImplementsIFooDirectly(t.BaseType)) { 
     return false; 
    } 
    foreach (var intf in t.GetInterfaces()) { 
     if (ImplementsIFooDirectly(intf)) { 
      return false; 
     } 
    } 
    return t.GetInterfaces().Any(i => i == typeof(IFoo)); 
} 

结果：

ImplementsIFooDirectly(typeof(IFoo)); // false 
ImplementsIFooDirectly(typeof(Bar)); // false 
ImplementsIFooDirectly(typeof(Foo)); // true 
ImplementsIFooDirectly(typeof(IBar)); // true 

它看起来并不为来自所有接口IFoo，它只是沿着继承/接口实现链，看看IFoo是否存在于除类型的确切级别以外的任何级别。

它还检测接口是否通过基类型继承。不知道这是你想要的。

不过，正如其他人已经说过的，如果这真的是你的需求，那么你的设计可能会有问题。 （编辑：只注意到你的问题纯属假设然后它的罚款，当然:)）。

Answer 2

您是否尝试过使用关键字is？

顺便说一句，如果你有一个合乎逻辑的情况，一些类需要是某种基类的类型而不是某个继承者，那么这可能是错误的OO设计，可能违反了Liskov substitution principle。

Answer 3

有关如何实现这些示例，请参见以下网站：

C# is keyword usage

从本质上讲，你可以用“是”关键字来确定对象是否存在于一个类类型，因为它的类继承堆栈的一部分。

class Director : Owner { } 
class Developer : Employee { } 
.. 
var dave = new Developer(); 
var steve = new Director(); 
var isEmployee = dave is Employee; // true 
var isAlsoEmploye = steve is Employee; // false 

在符合你的榜样作用：

bool Implements_Type(object instance, Type type) { 
return instance is type; 
} 

Answer 4

Type类有一个名为GetInterface方法可以使用。

bool Implements_IFoo(Type t) 
    { 
     return t.GetInterface(typeof(IFoo).Name) != null; 
    } 

Answer 5

static bool Implements_IFoo(Type type) 
{ 
    if (typeof(IFoo).IsAssignableFrom(type.BaseType)) 
    return false; 

    var barInterfaces = type.GetInterfaces() 
    .Where(iface => typeof(IFoo).IsAssignableFrom(iface)) 
    .ToArray(); 

    return barInterfaces.Length > 0 
    && barInterfaces.Length == barInterfaces.Count(iface => iface == typeof(IFoo)); 
} 
static bool Implements_IFoo_Optimized(Type type) 
{ 
    if (typeof(IFoo).IsAssignableFrom(type.BaseType)) 
    return false; 

    return type.GetInterfaces() 
    .Where(iface => typeof(IFoo).IsAssignableFrom(iface)) 
    .Count() == 1; 
} 

Answer 6

这应该做的伎俩：

public bool ImplementsIFooOnly(Type type) 
{ 
    return !type.GetInterfaces().Any(t => 
       { 
        return t is IFoo && !t.Equals(typeof(IFoo)); 
       }); 
} 

可能有更有效的方式。