Getting all types that implement an interface

Question

Using reflection  how can I get all types that implement an interface with C  3 0  NET 3 5 with the least code  and minimizing iterations   This is what I want to re-write   foreach  Type t in this GetType   Assembly GetTypes        if  t is IMyInterface              do stuff

User · Answer

Other answers here use IsAssignableFrom   You can also use FindInterfaces from the System namespace  as described here   Here s an example that checks all assemblies in the currently executing assembly s folder  looking for classes that implement a certain interface  avoiding LINQ for clarity    static void Main         const string qualifiedInterfaceName    Interfaces IMyInterface       var interfaceFilter   new TypeFilter InterfaceFilter       var path   Path GetDirectoryName Assembly GetExecutingAssembly   Location       var di   new DirectoryInfo path       foreach  var file in di GetFiles    dll              try               var nextAssembly   Assembly ReflectionOnlyLoadFrom file FullName               foreach  var type in nextAssembly GetTypes                      var myInterfaces   type FindInterfaces interfaceFilter  qualifiedInterfaceName                   if  myInterfaces Length  gt  0                           This class implements the interface                                           catch  BadImageFormatException                   Not a  net assembly  - ignore                    public static bool InterfaceFilter Type typeObj  Object criteriaObj        return typeObj ToString      criteriaObj ToString        You can set up a list of interfaces if you want to match more than one

User · Answer

You could use some LINQ to get the list   var types   from type in this GetType   Assembly GetTypes               where type is ISomeInterface             select type    But really  is that more readable

User · Answer

I got exceptions in the linq-code so I do it this way  without a complicated extension    private static IList lt Type gt  loadAllImplementingTypes Type   interfaces        IList lt Type gt  implementingTypes   new List lt Type gt             find all types     foreach  var interfaceType in interfaces          foreach  var currentAsm in AppDomain CurrentDomain GetAssemblies                try                               foreach  var currentType in currentAsm GetTypes                        if  interfaceType IsAssignableFrom currentType   amp  amp  currentType IsClass  amp  amp   currentType IsAbstract                          implementingTypes Add currentType                             catch          return implementingTypes

User · Answer

loop through all loaded assemblies  loop through all their types  and check if they implement the interface   something like   Type ti   typeof IYourInterface   foreach  Assembly asm in AppDomain CurrentDomain GetAssemblies          foreach  Type t in asm GetTypes              if  ti IsAssignableFrom t                    here s your type in t

User · Answer

There s no easy way  in terms of performance  to do what you want to do   Reflection works with assemblys and types mainly so you ll have to get all the types of the assembly and query them for the right interface  Here s an example   Assembly asm   Assembly Load  MyAssembly    Type   types   asm GetTypes    Type   result   types where x   gt  x GetInterface  IMyInterface      null     That will get you all the types that implement the IMyInterface in the Assembly MyAssembly

User · Answer

I appreciate this is a very old question but I thought I would add another answer for future users as all the answers to date use some form of Assembly GetTypes    Whilst GetTypes   will indeed return all types  it does not necessarily mean you could activate them and could thus potentially throw a ReflectionTypeLoadException   A classic example for not being able to activate a type would be when the type returned is derived from base but base is defined in a different assembly from that of derived  an assembly that the calling assembly does not reference    So say we have   Class A    in AssemblyA Class B   Class A  IMyInterface    in AssemblyB Class C    in AssemblyC which references AssemblyB but not AssemblyA   If in ClassC which is in AssemblyC we then do something as per accepted answer   var type   typeof IMyInterface   var types   AppDomain CurrentDomain GetAssemblies        SelectMany s   gt  s GetTypes         Where p   gt  type IsAssignableFrom p      Then it will throw a ReflectionTypeLoadException    This is because without a reference to AssemblyA  in AssemblyC you would not be able to   var bType   typeof ClassB   var bClass    ClassB Activator CreateInstance bType     In other words ClassB is not loadable which is something that the call to GetTypes checks and throws on   So to safely qualify the result set for loadable types then as per this Phil Haacked article Get All Types in an Assembly and Jon Skeet code you would instead do something like   public static class TypeLoaderExtensions       public static IEnumerable lt Type gt  GetLoadableTypes this Assembly assembly            if  assembly    null  throw new ArgumentNullException  assembly            try               return assembly GetTypes              catch  ReflectionTypeLoadException e                return e Types Where t   gt  t    null                       And then   private IEnumerable lt Type gt  GetTypesWithInterface Assembly asm        var it   typeof  IMyInterface       return asm GetLoadableTypes   Where it IsAssignableFrom  ToList

User · Answer

This worked for me  if you wish you could exclude system types in the lookup    Type lookupType   typeof  IMenuItem   IEnumerable lt Type gt  lookupTypes   GetType   Assembly GetTypes   Where          t   gt  lookupType IsAssignableFrom t   amp  amp   t IsInterface

User · Answer

I see so many overcomplicated answers here and people always tell me that I tend to overcomplicate things  Also using IsAssignableFrom method for the purpose of solving OP problem is wrong  Here is my example  it selects all assemblies from the app domain  then it takes flat list of all available types and checks every single type s list of interfaces for match  public static IEnumerable lt Type gt  GetImplementingTypes this Type itype         gt  AppDomain CurrentDomain GetAssemblies   SelectMany s   gt  s GetTypes                Where t   gt  t GetInterfaces   Contains itype

User · Answer

Even better when choosing the Assembly location  Filter most of the assemblies if you know all your implemented interfaces are within the same Assembly DefinedTypes      We get the assembly through the base class var baseAssembly   typeof baseClass  GetTypeInfo   Assembly      we filter the defined classes according to the interfaces they implement var typeList   baseAssembly DefinedTypes Where type   gt  type ImplementedInterfaces Any inter   gt  inter    typeof IMyInterface    ToList      By Can Bilgin

User · Answer

Other answer were not working with a generic interface   This one does  just replace typeof ISomeInterface  by typeof  T    List lt string gt  types   AppDomain CurrentDomain GetAssemblies   SelectMany x   gt  x GetTypes                 Where x   gt  typeof ISomeInterface  IsAssignableFrom x   amp  amp   x IsInterface  amp  amp   x IsAbstract               Select x   gt  x Name  ToList      So with  AppDomain CurrentDomain GetAssemblies   SelectMany x   gt  x GetTypes      we get all the assemblies   x IsInterface  amp  amp   x IsAbstract   is used to exclude the interface and abstract ones and   Select x   gt  x Name  ToList      to have them in a list

User · Answer

This worked for me  It loops though the classes and checks to see if they are derrived from myInterface   foreach  Type mytype in System Reflection Assembly GetExecutingAssembly   GetTypes                     Where mytype   gt  mytype  GetInterfaces   Contains typeof myInterface             do stuff

User · Answer

There are many valid answers already but I d like to add anther implementation as a Type extension and a list of unit tests to demonstrate different scenarios   public static class TypeExtensions       public static IEnumerable lt Type gt  GetAllTypes this Type type                var typeInfo   type GetTypeInfo            var allTypes   GetAllImplementedTypes type  Concat typeInfo ImplementedInterfaces           return allTypes             private static IEnumerable lt Type gt  GetAllImplementedTypes Type type                yield return type          var typeInfo   type GetTypeInfo            var baseType   typeInfo BaseType          if  baseType    null                        foreach  var foundType in GetAllImplementedTypes baseType                                 yield return foundType                                    This algorithm supports the following scenarios   public static class GetAllTypesTests       public class Given A Sample Standalone Class Type When Getting All Types           Given When Then Test               private Type  sut          private IEnumerable lt Type gt   expectedTypes          private IEnumerable lt Type gt   result           protected override void Given                          sut   typeof SampleStandalone                 expectedTypes                   new List lt Type gt                                        typeof SampleStandalone                       typeof object                                        protected override void When                          result    sut GetAllTypes                        Fact          public void Then It Should Return The Right Type                          result Should   BeEquivalentTo  expectedTypes                        public class Given A Sample Abstract Base Class Type When Getting All Types           Given When Then Test               private Type  sut          private IEnumerable lt Type gt   expectedTypes          private IEnumerable lt Type gt   result           protected override void Given                          sut   typeof SampleBase                 expectedTypes                   new List lt Type gt                                        typeof SampleBase                       typeof object                                        protected override void When                          result    sut GetAllTypes                        Fact          public void Then It Should Return The Right Type                          result Should   BeEquivalentTo  expectedTypes                        public class Given A Sample Child Class Type When Getting All Types           Given When Then Test               private Type  sut          private IEnumerable lt Type gt   expectedTypes          private IEnumerable lt Type gt   result           protected override void Given                          sut   typeof SampleChild                 expectedTypes                   new List lt Type gt                                        typeof SampleChild                       typeof SampleBase                       typeof object                                        protected override void When                          result    sut GetAllTypes                        Fact          public void Then It Should Return The Right Type                          result Should   BeEquivalentTo  expectedTypes                        public class Given A Sample Base Interface Type When Getting All Types           Given When Then Test               private Type  sut          private IEnumerable lt Type gt   expectedTypes          private IEnumerable lt Type gt   result           protected override void Given                          sut   typeof ISampleBase                 expectedTypes                   new List lt Type gt                                        typeof ISampleBase                                        protected override void When                          result    sut GetAllTypes                        Fact          public void Then It Should Return The Right Type                          result Should   BeEquivalentTo  expectedTypes                        public class Given A Sample Child Interface Type When Getting All Types           Given When Then Test               private Type  sut          private IEnumerable lt Type gt   expectedTypes          private IEnumerable lt Type gt   result           protected override void Given                          sut   typeof ISampleChild                 expectedTypes                   new List lt Type gt                                        typeof ISampleBase                       typeof ISampleChild                                        protected override void When                          result    sut GetAllTypes                        Fact          public void Then It Should Return The Right Type                          result Should   BeEquivalentTo  expectedTypes                        public class Given A Sample Implementation Class Type When Getting All Types           Given When Then Test               private Type  sut          private IEnumerable lt Type gt   expectedTypes          private IEnumerable lt Type gt   result           protected override void Given                          sut   typeof SampleImplementation                 expectedTypes                   new List lt Type gt                                        typeof SampleImplementation                       typeof SampleChild                       typeof SampleBase                       typeof ISampleChild                       typeof ISampleBase                       typeof object                                        protected override void When                          result    sut GetAllTypes                        Fact          public void Then It Should Return The Right Type                          result Should   BeEquivalentTo  expectedTypes                        public class Given A Sample Interface Instance Type When Getting All Types           Given When Then Test               private Type  sut          private IEnumerable lt Type gt   expectedTypes          private IEnumerable lt Type gt   result           class Foo   ISampleChild              protected override void Given                         var foo   new Foo                 sut   foo GetType                  expectedTypes                   new List lt Type gt                                        typeof Foo                       typeof ISampleChild                       typeof ISampleBase                       typeof object                                        protected override void When                          result    sut GetAllTypes                        Fact          public void Then It Should Return The Right Type                          result Should   BeEquivalentTo  expectedTypes                        sealed class SampleStandalone         abstract class SampleBase         class SampleChild   SampleBase         interface ISampleBase         interface ISampleChild   ISampleBase         class SampleImplementation   SampleChild  ISampleChild

User · Answer

To find all types in an assembly that implement IFoo interface   var results   from type in someAssembly GetTypes                 where typeof IFoo  IsAssignableFrom type                select type    Note that Ryan Rinaldi s suggestion was incorrect  It will return 0 types  You cannot write  where type is IFoo   because type is a System Type instance  and will never be of type IFoo  Instead  you check to see if IFoo is assignable from the type  That will get your expected results   Also  Adam Wright s suggestion  which is currently marked as the answer  is incorrect as well  and for the same reason  At runtime  you ll see 0 types come back  because all System Type instances weren t IFoo implementors

User · Answer

Edit  I ve just seen the edit to clarify that the original question was for the reduction of iterations   code and that s all well and good as an exercise  but in real-world situations you re going to want the fastest implementation  regardless of how cool the underlying LINQ looks   Here s my Utils method for iterating through the loaded types   It handles regular classes as well as interfaces  and the excludeSystemTypes option speeds things up hugely if you are looking for implementations in your own   third-party codebase   public static List lt Type gt  GetSubclassesOf this Type type  bool excludeSystemTypes        List lt Type gt  list   new List lt Type gt         IEnumerator enumerator   Thread GetDomain   GetAssemblies   GetEnumerator        while  enumerator MoveNext              try               Type   types     Assembly  enumerator Current  GetTypes                if   excludeSystemTypes     excludeSystemTypes  amp  amp     Assembly  enumerator Current  FullName StartsWith  System                        IEnumerator enumerator2   types GetEnumerator                    while  enumerator2 MoveNext                          Type current    Type  enumerator2 Current                      if  type IsInterface                            if  current GetInterface type FullName     null                                list Add current                                                   else if  current IsSubclassOf type                             list Add current                                                                   catch                       return list      It s not pretty  I ll admit

User · Answer

public IList lt T gt  GetClassByType lt T gt                 return AppDomain CurrentDomain GetAssemblies                              SelectMany s   gt  s GetTypes                               ToList p   gt  typeof T                             IsAssignableFrom p   amp  amp   p IsAbstract  amp  amp   p IsInterface                             SelectList c   gt   T Activator CreateInstance c

User · Answer

Mine would be this in c  3 0     var type   typeof IMyInterface   var types   AppDomain CurrentDomain GetAssemblies        SelectMany s   gt  s GetTypes         Where p   gt  type IsAssignableFrom p      Basically  the least amount of iterations will always be   loop assemblies    loop types     see if implemented

User · Answer

OfType Linq method can be used exactly for this kind of scenarios   https   docs microsoft com fr-fr dotnet api system linq enumerable oftype view netframework-4 8

[c#] Getting all types that implement an interface

Examples related to c#

Examples related to optimization

Examples related to reflection

Examples related to lambda

Examples related to c#-3.0