根据字典内容调用函数 C#

Question

I'm working on a program that will have a dictionary storing commands. There are two dictionaries, one of executables and one of internal functions. Right now, I'm just using the executable one, which has a command name attached to the path of the executable. It will check for the input in the dictionary and run the attached exe if possible and run that command. I started the function dictionary because there are some functions that are not executables. Would it be possible to do the same thing I did with the executables with functions inside the program?

    private Dictionary<string, string> ExternalCommands = new Dictionary<string, string>
    {
        {"help", @".\help.exe"}
    };


    private Dictionary<string, string> InternalFunctions = new Dictionary<string, string>
    {
        **{"exit", function()}**
    };
    public int Execute(string input)
    {
        try
        {
            if (ExternalCommands.Keys.Contains(input))
            {
                var process = new Process();
                process.StartInfo = new ProcessStartInfo(ExternalCommands[input])
                {
                    UseShellExecute = false
                };

                process.Start();
                process.WaitForExit();

                return 0;
            }
            Console.WriteLine($"{input} NOT FOUND");
            return 1;
        }
        catch
        {
            return 1;
        }

Answer 1

How you would do this depends upon the method signatures and what, if any, parameters you need to pass. In general, though, you'd need to create a dictionary of delegates. Action and Func are pretty easy to use in this situation.

Something like this would work:

private void Test()
{
    var commands = new Dictionary<string, Action>();
    commands.Add("exit", Exit);
    commands.Add("greet", SayHello);

    commands["greet"]();
    commands["exit"]();
}

private void Exit()
{
    this.Close();
}

private void SayHello()
{
    MessageBox.Show("Hello!");
}

You could also use lambda expressions to add delegates to such a dictionary for even more flexibility:

commands.Add("exit", () => this.Close());
commands.Add("greet", () => MessageBox.Show("Hello!"));

Answer 2

For voids you can use Action , if the function has parameters you use Action<T> where T is it the type, for example: Action<string> . If your functions return something you can use Func , example for a function which takes a string as an input and returns int : Func<string, int> . You can use these as values for the dictionary. Here is an example code for a hello world application:

    class Program
    {
        public static Dictionary<string, Action> FunctionsInDictionary = new Dictionary<string, Action>()
        {
            { "helloworld", HelloWorld }
        };

        static void Main(string[] args)
        {

            FunctionsInDictionary["helloworld"].Invoke();

            Thread.Sleep(-1);
        }

        static void HelloWorld()
        {
            Console.WriteLine("Hello World!");
        }
    }