Get all derived types of a type

by

I once used this Linq-method to get all types inheriting from a base type B:

    var listOfBs = (
                from domainAssembly in AppDomain.CurrentDomain.GetAssemblies()
                // alternative: from domainAssembly in domainAssembly.GetExportedTypes()
                from type in domainAssembly.GetTypes()
                where typeof(B).IsAssignableFrom(type)
                // alternative: && type != typeof(B)
                // alternative: && ! type.IsAbstract
                // alternative: where type.IsSubclassOf(typeof(B))
                select type).ToArray();

EDIT: As this still seems to get more rep (thus more views), let me add a fluent version and some more details:

   var listOfBs = AppDomain.CurrentDomain.GetAssemblies()
                // alternative: .GetExportedTypes()
                .SelectMany(domainAssembly => domainAssembly.GetTypes())
                .Where(type => typeof(B).IsAssignableFrom(type)
                // alternative: => type.IsSubclassOf(typeof(B))
                // alternative: && type != typeof(B)
                // alternative: && ! type.IsAbstract
                ).ToArray();

Details:

  • As the above-mentioned link states, this method uses Reflection on each call. So when using the method repeatedly for the same type,
    one could probably make it much more efficient by loading it once.
  • As Anton suggests, maybe you could (micro)optimize it using domainAssembly.GetExportedTypes()
    to retrieve only publicly visible types (if that’s all you need).
  • As Noldorin mentions, Type.IsAssignable will also get the original (non-derived) type. (Type.IsSubclassOf will not, but Type.IsSubclassOf will not work if the base type is an interface). But of course, one can exclude the original base class: && type != typeof(B).
  • One may want/need to check for a concrete implemented class, i.e. ignore abstract classes: && ! assemblyType.IsAbstract. (Note that all interfaces are considered abstract, see MSDN.)
  • FWIW: as Jon Skeet suggested in a similar question: “it is trickier if you need to handle generics”.
    A quick search returns some suggestions, but there are probably more, and I did not check them (e.g. for correctness):

More Related Contents:

  1. Calling the base constructor in C#
  2. Testing if object is of generic type in C#
  3. How can I get all constants of a type by reflection?
  4. How to determine if a type implements a specific generic interface type
  5. Purpose of Activator.CreateInstance with example?
  6. Reflection – Getting the generic arguments from a System.Type instance
  7. Convert.ChangeType() fails on Nullable Types
  8. Using Case/Switch and GetType to determine the object [duplicate]
  9. What’s the correct alternative to static method inheritance?
  10. What is the “cost” of .NET reflection? [duplicate]
  11. How can you get the names of method parameters?
  12. How to check whether an object has certain method/property?
  13. GetProperties() to return all properties for an interface inheritance hierarchy
  14. Using PropertyInfo to find out the property type
  15. Invoking methods with optional parameters through reflection
  16. Check if a property exists in a class
  17. How to copy value from class X to class Y with the same property name in c#?
  18. Is there a way to get a type’s alias through reflection?
  19. Finding out if a type implements a generic interface
  20. C#: how to get an object by the name stored in String?
  21. Is there any way to call the parent version of an overridden method? (C# .NET)
  22. C# Covariance on subclass return types
  23. Can I Override with derived types?
  24. Why does this polymorphic C# code print what it does?
  25. Dynamically creating a proxy class
  26. How can I protect my private funcs against reflection executing?
  27. Using Reflection to create a DataTable from a Class?
  28. Get private Properties/Method of base-class with reflection
  29. Reflecting a private field from a base class
  30. Two Types not equal that should be

Leave a Comment