It’s sometimes useful to auto-discover types in C# and other high-level programming languages, even outside the context of coding an IoC container. In C#, robust type-discovery mechanisms make this easy. Here’s a basic formula for auto-discovery of types implementing an interface:
1. Get the list of assemblies in the application domain.
2. Get the types from each discovered assembly.
3. Test each type to see whether it implements the target interface.
This basic formula can be accomplished in a snap using Linq:
var targetType = typeof(someInterface); var types = AppDomain.CurrentDomain.GetAssemblies() .SelectMany(a => a.GetTypes()) .Where(t => t.GetInterfaces().Contains(targetType) && t.IsClass && !t.IsAbstract) .OrderBy(t => t.FullName);
!t.IsInterface) in the above expression excludes the interface itself, as well as derived interfaces. The
.IsAbstract check can be skipped if the goal is to discover all class types for the interface, not just those that can actually be instantiated. Lastly, the basic approach is similar but the calls not identical for .NET Core.