How to call specific function depending on a variable?

Question

I'm generating a random number from 1-1000. I have 200 functions named function1, function4, function 10, function 11, etc. What I would like to do is execute a specific function depending on if the number generated requires a function, and ignore it if not. My first thought was to create an int[] containing all of the values that would trigger a function, and if the int[] contains the random number to use if statements to figure out what the number is. I'm concerned that it must be a really crude solution to an easy problem though. I know the "best way" to do something is subjective, but is there a better way to accomplish this?

Answer 1

UPDATE: As per comments, I should probably have started out by pointing out that doing this for 200 functions is probably a good sign that there is some serious issue in your design. This is probably an XY question where you are trying to solve a problem in some crazy way and asking about your intended solution instead of asking about the problem itself.

That said I'll leave the original answer because it's still good advice when mapping a reasonable amount of function calls that can/will change during the life cylce of your app or dynamically as the code runs.

---

I won't get into why you are doing this, but I'll try to at least point you in the right direction so this doesn't become a complete nightmare when you need to modify/expand behavior:

You can map numbers to function calls using delegates and a dictionary. Assuming your functions take no arguments and return void you'd do:

var functionsMap = new Dictionary<int, Action>();
//map functions
var r = getSomeRandomNumber();

if (functions.TryGetValue(r), out var a)
    a(); //invoke function

Mapping functions is simply adding keys and values:

functionsMap.Add(1, () => function1());
functionsMap.Add(3, () => function3());
//etc.

If your functions take arguments or return values, you'd use the adequate delegate: Action<T>, Func<T1, T2> etc.

Answer 2

You can use reflection to invoke appropriate method:

Type exampleType = exampleObject.GetType();
MethodInfo exampleMethod = exampleType.GetMethod(methodName); 
exampleMethod.Invoke(this, null);

Where methodName can be created using your random number.

Answer 3

Without commenting on the wisdom of having 200 functions named the way yours are, you can use reflection to determine whether a given functionX() exists, like so:

public void ExecuteDynamicMethod(int number)
{
    // Modify these two lines with your app's dll/exe and class type:
    Assembly assembly = Assembly.LoadFile("...Assembly1.dll");
    Type type = assembly.GetType("YourClassType");

    if (type != null)
    {
        MethodInfo methodInfo = type.GetMethod("function" + number);

        if (methodInfo != null)
        {
            object classInstance = Activator.CreateInstance(type, null);
            methodInfo.Invoke(classInstance, null);  // null = "no function arguments"
        }
    }
}

This can then be called for a given value like

ExecuteDynamicMethod(14);

See this SO answer for the inspiration behind this.

Answer 4

Reflection can be used for this purpose. I want to give and keep below example for not only the objective of the question but also for future reference. Also, of course that many function is not good but below code shows the approach that can work with many functions if they have similar name (like starting with "function" keyword).

Assume below is Methods.cs

using System;
using System.Reflection;

namespace YourMethodNamespace
{    
    public class YourMethodClass
    {
        public void function1()
        {
            Console.WriteLine("Function-1");
        }

        public void function2()
        {
            Console.WriteLine("Function-2");
        }

        ...

        public void function200()
        {
            Console.WriteLine("Function-200");
        }

        public static void invokeMethodsDynamically(int randomNumber){
            Type yourClassType = typeof(YourMethodClass);
            ConstructorInfo yourClassConstructorInfo = yourClassType.GetConstructor(Type.EmptyTypes);
            object yourClassObject = yourClassConstructorInfo.Invoke(new object[]{}); 

            //If the constructor has parameters, then we can pass them by this way. Like below;
            /*ConstructorInfo yourClassConstructorInfo = yourClassType.GetConstructor(new[]{typeof(int)});
            object yourClassObject = yourClassConstructorInfo.Invoke(new object[]{3});
            */

            MethodInfo[] methodInfoArr = yourClassType.GetMethods();
            foreach(MethodInfo methodInfo in methodInfoArr){
                if(methodInfo.Name == "function" + randomNumber){
                    methodInfo.Invoke(yourClassObject, null);
                }
            }
        }
    }
}

Let's say below is Program.cs

using System;
using YourMethodNamespace;

namespace YourProgramNamespace
{       
    public class YourProgramClass
    {
        public static void Main()
        {
            Random random = new Random();
            int randomNumber = random.Next(1, 201);             

            //If Methods.cs is in another Assembly

            /*string pathToDllAssembly = @"Domain.dll";
            Assembly dllAssembly = Assembly.LoadFrom(pathToDllAssembly);
            Type methodsClassType = dllAssembly.GetType("YourMethodNamespace.YourMethodClass");
            ConstructorInfo methodClassConstructorInfo = methodsClassType.GetConstructor(Type.EmptyTypes);
            object methodsClassObject = methodClassConstructorInfo.Invoke(new object[]{});
            MethodInfo methodInfo = methodsClassType.GetMethod("invokeMethodsDynamically");
            methodInfo.Invoke(methodsClassObject, new object[]{randomNumber});
            */

            YourMethodClass.invokeMethodsDynamically(randomNumber, null);
        }
    }
}

Also for testing and observing, below link can be used.

https://repl.it/@erdsavasci/ReflectionTest