In C# is it possible to instantiate all class found in a namespace?

Question

In C# is it possible, without reflection, to instantiate all class found in a namespace?

I have a list of script class. All in same folder. All implementing my base class BaseScript. I need to run all of them every hours. I already have the time and events. I also already have a List<BaseScript> ListOfScripts. But now I'm doing this:

    public class Program
    {
        private static List<BaseScript> ListOfScrpits { get; set; }

        static void Main(string[] args)
        {
            ListOfScrpits = new List<BaseScript>
            {
                new DoThis(),
                new DoThat(),
                new DoSomethingElse()
            };

            Timer timer = new Timer();
            timer.Interval = 600000; // 10 * 60 seconds 
            timer.Elapsed += new ElapsedEventHandler(OnTimer);
            timer.Start();
        }
        private static void OnTimer(object sender, ElapsedEventArgs e)
        {
            // TODO
        }
    }

Can I create my list of scripts dynamically?

Answer 1

I'd suggest using a Dependency Injection container here to handle the instantiation of the classes for you. The benefit of using DI here is that it allows your classes to be much more extensible. For example, if you end up needing some other dependencies in any of your classes implementing BaseScript, the DI container will handle resolving those for you so long as they're registered.

You can do this with pretty easily with the ServiceCollection available in .NET Core:

class Program
{
    private static List<BaseScript> ListOfScrpits { get; set; }

    static void Main(string[] args)
    {
        ServiceProvider serviceProvider = new ServiceCollection()
            .AddTransient<BaseScript, DoThis>()
            .AddTransient<BaseScript, DoThis>()
            .AddTransient<BaseScript, DoSomethingElse>()
            .BuildServiceProvider();

        ListOfScrpits = serviceProvider.GetServices<BaseScript>().ToList();

        foreach (BaseScript script in ListOfScrpits)
            Console.WriteLine(script.GetType().Name);

        Console.ReadLine();
    }
}

You can even register all instances of your BaseScript (using Reflection as seen in other answers) so that new implementations will be automatically resolved and used as you add them. Just change the serviceProvider bit to:

System.Reflection.Assembly[] assemblies = new[] { System.Reflection.Assembly.GetExecutingAssembly() };
IEnumerable<Type> scriptTypes = assemblies
    .SelectMany(a => a.GetTypes())
    .Where(t => t != typeof(BaseScript) && typeof(BaseScript).IsAssignableFrom(t) && !t.IsAbstract);

ServiceCollection serviceCollection = new ServiceCollection();
foreach (Type scriptType in scriptTypes)
    serviceCollection.AddTransient(typeof(BaseScript), scriptType);

ServiceProvider serviceProvider = serviceCollection.BuildServiceProvider();

A working example can be seen here: https://dotnetfiddle.net/xBqsNg

Answer 2

Based on your requirements, and your latest comment suggesting you would accept reflection, I suggest the following:

// add any assemblies you want to discover scripts in here
var assemblies = new[] { System.Reflection.Assembly.GetExecutingAssembly() }; 

var scriptTypes = assemblies
    // get the declared types for each and every assembly
    .SelectMany(a => a.GetTypes())
    // filter so that we ignore BaseClass, only accept types assignable to base class,
    // don't accept abstract classes and only accept types with a parameterless constructor
    .Where(t => t != typeof(BaseClass) && typeof(BaseClass).IsAssignableFrom(t) && !t.IsAbstract && t.GetConstructors().Any(c => c.GetParameters().Length == 0));

// create an instance of each type and construct a list from it
var scripts = scriptTypes
    .Select(t => (BaseClass)Activator.CreateInstance(t))
    .ToList();