A simple utility for discovering and instantiating classes by interface or inheritance using
reflection. Perfect for plugin systems, dynamic class loading, and educational purposes.
Overview
MMPClassEnumerator eliminates boilerplate code when working with plugins or dynamic class
discovery. Instead of manually instantiating each class with switch statements, discover
and create instances automatically using reflection.
Features
✅ Interface-based Discovery - Find classes implementing specific interfaces
✅ Inheritance-based Discovery - Find classes inheriting from base classes
Before - Manual instantiation with switch statements:
ITopic topic;
switch(choice)
{
case 0: topic = new Topic0(); break;
case 1: topic = new Topic1(); break;
case 2: topic = new Topic2(); break;
// Long list of cases...
}
The Solution
After - Dynamic discovery and instantiation:
using MarcusMedinaPro.ClassEnumerator;
// Get all classes implementing ITopic
var topics = EnumerateClasses<ITopic>.GetClassesByInterface().ToList();
// Display options
for (int i = 0; i < topics.Count; i++)
Console.WriteLine($"{i:00} {topics[i].GetType().Name}");
// User selects
Console.Write("Select a topic: ");
var choice = int.Parse(Console.ReadLine()!);
// Use selected instance directly
ITopic topic = topics[choice];
API Reference
Get Instances by Interface
Returns instantiated objects of all classes implementing the specified interface:
public interface IPlugin
{
string Name { get; }
void Execute();
}
// Auto-discover and load all plugins
var plugins = EnumerateClasses<IPlugin>.GetClassesByInterface().ToList();
// Display available plugins
plugins.ForEach(p => Console.WriteLine($"Plugin: {p.Name}"));
// Execute all plugins
plugins.ForEach(p => p.Execute());
List All Classes in Assembly
// Get all classes (using object as base)
var allClasses = EnumerateClasses<object>.GetClassesByInheritance().ToList();
// Display class names
allClasses.ForEach(c => Console.WriteLine($"class {c.GetType().Name}()"));
Menu System
public interface IMenuItem
{
string DisplayName { get; }
void Run();
}
var menuItems = EnumerateClasses<IMenuItem>.GetClassesByInterface().ToList();
// Display menu
for (int i = 0; i < menuItems.Count; i++)
Console.WriteLine($"{i + 1}. {menuItems[i].DisplayName}");
// Execute selected item
int selection = int.Parse(Console.ReadLine()!) - 1;
menuItems[selection].Run();
How It Works
MMPClassEnumerator uses .NET reflection to:
Scan the calling assembly for types
Filter types matching the specified interface or base class
Verify types have parameterless constructors
Optionally create instances via Activator.CreateInstance()
Return results sorted by type name
Requirements and Limitations
Parameterless Constructor: All discovered classes must have a public parameterless constructor
Calling Assembly: Only scans the assembly that calls the method
Performance: Reflection has overhead - cache results if calling frequently
Educational Purpose
This library was created as an educational tool to demonstrate:
Reflection API: How to discover types at runtime
Generic Programming: Using generic type parameters
Why CC BY-SA 4.0? The core reflection logic is inspired by Stack Overflow code,
which is licensed under CC BY-SA per Stack Overflow's terms of service.
