Determine if a derived class implements a generic interface with itself as the generic parameter

Question

I have seen answers on SO with similar questions but did not find one addressing all criteria below.

How can I determine whether class B meets the following criteria when B inherits from A:

[B] does not implement any [additional] interfaces (generic or not).
[A] implements a generic interface with its own type as the generic parameter?

The following

object o = new SomeObject();
bool result = (o.GetType().GetInterfaces()[0] == typeof(IKnownInterface<???>));
// ??? should be typeof(o). How to achieve this?

I know I can get the interface name string from the type which is something like "NameSpace.ClassName+IKnownInterface'1[[SomeType, ModuleName, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]]" but this does not seem intuitive or safe. Plus the '1 notation is incremental based on the number of generic types used for that interface.

I am either going about this the wrong way or missing something silly here. Please advise.

If `B` inherits from `A` it's *impossible* for `A` to implement an interface and `B` to not. `B`, by definition, implements all interfaces `A` does. — Servy, May 13 '13 at 17:51
I'll update my question. What I meant was that B does not implement any additional interfaces that A does not have. — Raheel Khan, May 13 '13 at 17:55
Can you explain _why_ you'd want to check your devs like that? Unit tests should point at black boxes, the implementation shouldn't matter. Consider the example of an `IEmailer` which is internally instantiated from a factory which requires `IInstantiable` (contrived I know but...). As long as it works as an IEmailer, why do you care what else it is? You're attempting to unit test the implementation not the functionality — Basic, May 13 '13 at 19:03
@Basic: Unit tests may not be the ideal way to enforce this but it sure is convenient. In my scenario, I have some important classes that have an extremely narrow scope and should not be doing anything besides they are expected to do. In other words, small liberties taken by developers can potentially break the system. This is one of many simple pre-quality-control checks we have for such classes. It makes code logic verification and testing much simpler. — Raheel Khan, May 13 '13 at 19:07
Thanks. Would you mind giving an example of a problem this might avoid? I've never seen a test for this before and would be interested to know. Please feel free not to answer should prefer :) — Basic, May 13 '13 at 19:10
@Basic: Please have a look at my [[original question here](http://stackoverflow.com/questions/16524235/verifying-code-against-template-patterns-using-reflection)] for more context and usage. See Daniel Hilgarth's answer and the discussion below. As for what problems it may help avoid, this was an after-the-fact measure rather than a forward-looking strategy. — Raheel Khan, May 13 '13 at 21:06
@RaheelKhan Thanks for the link, No offense but I can't tell you how happy I am I'm not working on that project. Restrictions like that would send me postal within a few months. Good luck on the rewrite in 2 years time. I hope by then you've hired/trained your devs so they can handle details like this themselves. — Basic, May 13 '13 at 21:39

score 2 · Accepted Answer · answered May 13 '13 at 18:00

2

This should do the trick

//get the two types in question
var typeB = b.getType()
var typeA = typeB.BaseType;
var interfaces = typeA.GetInterfaces();

//if the length are different B implements one or more interfaces that A does not
if(typeB.GetInterfaces().length != interfaces.length){
   return false;
} 

//If the list is non-empty at least one implemented interface satisfy the conditions
return (from inter in interfaces
        //should be generic
        where inter.IsGeneric
        let typedef = inter.GetGenericTypeDefinition()
        //The generic type of the interface should be a specific generic type
        where typedef == typeof(IKnownInterface<>) &&
        //Check whether or not the type A is one of the type arguments
              inter.GetGenericTypeArguments.Contains(typeA)).Any()

answered May 13 '13 at 18:00

Rune FS

21,497
7
62
96

Thank you. I'm wondering why your code does not need to include the `typeof(IKnownInterface<>).MakeGenericType(o.GetType())` method as in @NechytailoOleh's answer. – Raheel Khan May 13 '13 at 18:04
@RaheelKhan It kind of does. ´let typedef = inter.GetGenericTypeDefinition()` and the following line does the same – Rune FS May 13 '13 at 18:07
Ah I see. I prefer NechytailoOleh's compact comparison but got both points answered here. Thanks again. – Raheel Khan May 13 '13 at 18:15
@RaheelKhan the compact version only works with one generic type argument. I was under the assumption that it should work with multiple type arguments where one of them should be A – Rune FS May 13 '13 at 18:23
I know and agree. My preference was based solely on the 'Yuckiness' that Query Syntax has for me (even though it is recommended over Method Syntax). Nothing to do with function, just the form. :P – Raheel Khan May 13 '13 at 18:42

score 1 · Answer 2 · answered May 13 '13 at 17:55

1

try:

 o.GetType().GetInterfaces()[0] == 
                   typeof(IKnownInterface<>).MakeGenericType(o.GetType())

http://msdn.microsoft.com/en-us/library/system.type.makegenerictype.aspx

answered May 13 '13 at 17:55

Oleh Nechytailo

2,155
17
26

Hah! First of all, I did not even know you could use an empty `<>` generic notation. Secondly, wouldn't that mean `IKnownInterface<>` could be of any generic type? I understand your answer with `MakeGenericType` but just want to know how to interpret the `<>` notation. Also, how could I tell if `[o]` implements any interfaces that its base class does not? Is there some kind of a BindingFlag or would you have to enumerate interfaces for both types and compare? – Raheel Khan May 13 '13 at 18:00
1

The `typeof(...<>)` means any generic variation of `IKnownInterface` the `MakeGeneric` specifically returns the correct type for `IKnownInterface<"type of o">` – Basic May 13 '13 at 18:05
1

@RaheelKhan you do not need to compare interfaces of the two classes. You can just compare the number of interfaces implemented. Since B will have all interfaces from A the only way the length can differ is if B implements some that A does not (see my answer for completeness) – Rune FS May 13 '13 at 18:06
@RuneFS: Thank you! I should have thought of that :). – Raheel Khan May 13 '13 at 18:08
@Basic: Thank you. That will be valuable. – Raheel Khan May 13 '13 at 18:43
@RaheelKhan The empty `<>` means "type with exactly one type argument". It can only be used with the `typeof` keyword. To give other examples, consider `typeof(Action)` (nongeneric), `typeof(Action<>)` (one type parameter), `typeof(Action<,>)` (two), `typeof(Action<,,>)` (three). These are called `"Action"`, ``"Action`1"``, ``"Action`2"``, ``"Action`3"``, and so on, by the runtime/framework. – Jeppe Stig Nielsen May 13 '13 at 18:44
@JeppeStigNielsen: I was under the impression that even `"Action"` and `"Action"` would produce unique types such as "Action`1" and "Action`2". Or do these numbers only have to do with the number of generic parameters? – Raheel Khan May 13 '13 at 18:48
@RaheelKhan: If `A` inherits from `B`, implements non-contravariant interface `IFoo`, and implements the same number of interfaces as `B`, that would imply that `B` implements `IFoo `. While it would be possible for `B` to do so, it would seem a little odd. If `IFoo<>` is contravariant with regard to its type parameter, an implementation of `IFoo` would also be an implementation of `IFoo`, but I don't think that's what you're intending to look for. – supercat May 13 '13 at 18:52
@supercat: That's right. My intention is to make sure that no additional interfaces are implemented on the classes derived from `A`. This is used in unit tests to ensure that developers have not deviated from the guidelines provided to them for specific types. – Raheel Khan May 13 '13 at 18:59
**Edit:** Moved comment to Question – Basic May 13 '13 at 19:02
@RaheelKhan: If some class Q is derived from A, are you wanting Q to implement IKnownInterface but not IKnownInterface, or is A going to implement IKnownInterface, or what? – supercat May 13 '13 at 19:15
@supercat: Class A implements IKnownInterface. I can verify that easily. I also want to make sure that Q does NOT implement any additional interfaces. So if I write class A and send you the assembly, I would expect you to return class Q derived from A without adding any interfaces to it. It already implicitly implements IKnownInterface by virtue of the base class. Hope that answers your question. – Raheel Khan May 13 '13 at 21:02
@RaheelKhan: So you want Q not to implement `IKnownInterface`. In that case, I understand your second requirement regarding implementing a particular generic interface. If A implements an interface, the fact that Q inherits from A implies that Q implements it as well. – supercat May 13 '13 at 23:14

Determine if a derived class implements a generic interface with itself as the generic parameter

2 Answers2