How to determine if a type implements an interface with C# reflection

Question

Does reflection in C# offer a way to determine if some given System.Type type models some interface?

public interface IMyInterface {}

public class MyType : IMyInterface {}

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

Solution 1

You have a few choices:

1. typeof(IMyInterface).IsAssignableFrom(typeof(MyType))
2. typeof(MyType).GetInterfaces().Contains(typeof(IMyInterface))
3. With C# 6 you can use typeof(MyType).GetInterface(nameof(IMyInterface)) != null

For a generic interface, it’s a bit different.

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

Solution 2

Use Type.IsAssignableFrom:

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

Solution 3

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

or

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

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

I think this is the correct release, for three reasons:

1. It uses GetInterfaces and not IsAssignableFrom, it's faster since IsAssignableFrom eventually after several checks does call GetInterfaces.
2. It iterates over the local array, so there will be no bounds checks.
3. It uses the == operator which is defined for Type, so probably is safer than the Equals method (that the Contains call, will eventually use).

Solution 5

Use Type.IsAssignableTo (as of .NET 5.0):

typeof(MyType).IsAssignableTo(typeof(IMyInterface));

As stated in a couple of comments IsAssignableFrom may be considered confusing by being "backwards".

View more solutions

Comments

[James J. Regan IV]

If you already have an instance of the class a much better approach is simply someclass is IMyInterface as that doesn't involve the cost of reflection at all. So, while not wrong, its not an ideal way to do it.

[Chris Kemp]

Remember that typeof(IMyInterface).IsAssignableFrom(typeof(IMyInterface)) is also true, which may have an unexpected result on your code.

[Benjamin]

It sure was easy to not pay attention and get the arguments for IsAssignableFrom backwards. I will go with GetInterfaces now :p

[Pierre Arnaud]

The IsAssignableFrom(t1) variant is about 3x faster than the GetInterfaces().Contains(t2) counterpart in my code.

[Angshuman Agarwal]

@James - Agree. Even Resharper gives the same suggestion.

[Kosta]

You can also use typeof(MyType).GetInterface("IMyInterface") != null

[Panos Theof]

@PierreArnaud: IsAssignableFrom does eventually calls GetInterfaces, so probably your test checked the GetInterfaces first and IsAssignable after. That is because GetInterfaces caches it's results so the first invocation costs more

[Pierre Arnaud]

My performance test of IsAssignableFrom was done by repeatedly calling it with the same arguments. So yes, any caching done by this method would produce significant speed ups.

[reggaeguitar]

+1 for content, I hate the spaces around the parens and the Egyptian braces though. Also the whole method can be written as: return type.GetInterfaces().Any(t => t == ifaceType);

[reggaeguitar]

@JamesJ.ReganIV you should post that as an answer, I almost missed your comment

[James J. Regan IV]

@reggaeguitar, thanks, but the comment doesn't answer the original question. The question asks for the Reflection solution, I am just saying in this answer's first case where you do have an instance of the object reflection isn't the ideal solution.

[gdbdable]

Type.IsAssignableFrom() internaly acts exactly like your code

[Rémi]

as of the writing of this comment, your at 404, here a +1 so you can be found again

[edc65]

This is obvious when I have an instance. Not useful when I have a Type from reflection

[aholmes]

A small change to @Kosta's answer. With C# 6 we can do typeof(MyType).GetInterface(nameof(IMyInterface)) != null for better type safety and refactoring.

[Admin]

Also why not type.GetInterfaces().Contains(ifaceType) which doesnt use LINQ.

[Mark A. Donohoe]

Is there a reason you didn't just put the implementation directly in the extension method? I mean sure this lets you call it both ways, but why would you ever need to do that?

[Sellorio]

Still holds the risk of multiple interfaces with the same name.

[Sellorio]

@JamesJ.ReganIV Actually, is checks in both directions of the inheritance hierarchy whereas IsAssignableFrom only checks upwards. Also, if you have an instance of an object, you should call IsInstanceOfType (which also only looks upwards).

[Sellorio]

Did some tests and it appears that IsAssignableFrom is 6x faster than GetInterfaces().Contains. On a side note, GetInterfaces is cached but IsAssignableFrom is not. Even with the caching GetInterfaces().Contains is 3.5x slower than IsAssignableFrom.

[Jon Hanna]

@MrUniverse is only checks in one direction, or else new object() is string would be true.

[Sellorio]

@JonHanna That's not exactly what I meant but I think I was confused.

[VV5198722]

As you can see in accepted answer, you interchanged the types in usage of IsAssignableFrom. Just like Benjamin and Ehouarn warn about.

[Sindri Jóelsson]

You could do return typeof(I).IsInterface && typeof(I).IsAssignableFrom(source); to return false on any 'incorrect' usages of the method, that is; using it with a class type instead of an interface type, alternatively throw an exception if the type-parameter is not an interface. Though you could argue that a derived class 'implements' it's parent...

[Natalie Perret]

@MarqueIV sorry to get back to you almost 2 years late, well I guess it was an old bad habit back then to wrap helper method in extension method to avoid repeating code, will edit my answer :)

[Natalie Perret]

@MarqueIV done plus changed my other bad habit of not using alias , i.e. Boolean => bool (I don't why I used to have some strict "fancy" rules of coding when I was younger).

[adospace]

One more note, IsAssignableFrom returns true only if the interface is "directly" implemented by the type: i.e. interface A{} interface B:A{} class C:B{} typeof(C).IsAssignableFrom(typeof(A)) returns false while typeof(C).GetInterfaces().Contains(typeof(A)) or typeof(C).GetInterface(nameof(A)) != null are both true

[Suncat2000]

@adospace It should be typeof(IMyInterface).IsAssignableFrom(typeof(MyType)) if you want to test if MyType implements IMyInterface. To help remember the correct order: // If you can do this... if (typeof(IMyInterface).IsAssignableFrom(typeof(MyType)) { // then you can do this... IMyInterface obj = new MyType(); }

[Maxim]

Your solution will only work for existing objects. It is not applicable for types. Moreover, if you have a created object, you can get its type and perform the necessary checks.