How to call methods in all classes?

Question

Now the simplest example i can give of what im talking about is as followed.

In Unity3D there are several methods. void Awake(), void Start().

So what I'm trying to create is several classes that all contain the method void Start() and I want the void Main() method to call all of these start methods dynamically. I do not want to have to type Class test = new Class() etc.

If anyone can head me in the correct direction or even give me some example code that would be great.

Answer 1

So you could loop through every type and figure out if that type has a method called Start with the exact signature you need. Perhaps better would be to create an interface and make all your classes implement that. For example:

public interface IStartable
{
    void Start();
}

public class SomeClass : IStartable
{
    public void Start()
    {
        Console.WriteLine("Starting inside SomeClass");
    }
}

Now you can loop through all loaded assemblies and search for implementations of IStartable, for example:

var instances = AppDomain.CurrentDomain.GetAssemblies()
    .SelectMany(a => a.GetTypes())
    .Where(t => t.IsClass && typeof(IStartable).IsAssignableFrom(t))
    .Select(t => (IStartable)Activator.CreateInstance(t));

foreach (var instance in instances)
{
    instance.Start();
}

This is assuming all those classes have a public, parameterless constructor.

This will work but isn't particularly efficient. If you wanted to scale this up a bit, then you might want to look at other options such as Managed Extensibility Framework.

To make this more generic and useful in more situations, here it is wrapped in a method you can apply to any type:

public void RunOnAll<T>(Action<T> action) 
{
    var instances = AppDomain.CurrentDomain.GetAssemblies()
        .SelectMany(a => a.GetTypes())
        .Where(t => t.IsClass && typeof(T).IsAssignableFrom(t))
        .Select(t => (T)Activator.CreateInstance(t));

    foreach (var instance in instances)
    {
        action(instance);
    }
}

So now you would call it like this:

RunOnAll<IStartable>(x => x.Start());

Answer 2

I will not provide you code, but the mean idea is to do something like this:

1. Create a abstract class or interface which all your wanted classes extends from
2. Scan the Assembly for classes that inherit from that class https://stackoverflow.com/a/17680332/1514875
3. You now have a list of classes
4. Loop over the classes and use Activator.CreateInstance to create a instance https://msdn.microsoft.com/en-us/library/wccyzw83(v=vs.110).aspx
5. Use reflection to get the method https://msdn.microsoft.com/en-us/library/system.type.getmethod(v=vs.110).aspx
6. Call Invoke with your created instance on the returned MethodInfo https://www.dotnetperls.com/methodinfo-invoke

Answer 3

Its not entirely clear what youre asking, but if you want to load and create class intances at run time, the area youre looking for is called reflection: (https://learn.microsoft.com/en-us/dotnet/framework/reflection-and-codedom/reflection). This allows .net to effectively analyze and obtain information about its own codebase.

In your case, you would be able to load up all the of the classes you were interested in (based on their name, or some other rule), create instances and call the start method all without this information being available at compile time.