Create a seed or string to run multiple methods. C#

Since we have quite a few implementations already, I just want to add my LogicExpressionParser which is an improved version of my old ExpressionParser. It can actually parse maths equations that may be fed into custom functions. The LogicExpressionParser has the addition of boolean operators and boolean expressions.

Of course a single expression is evaluated "at once", so there is no real chaining of methods. However if you just split your string into individual function calls you can actually utilize the full power of the parser. So registrated functions can take multiple arguments (only numbers, doubles to be more precise) and the arguments could be a mathematical expression. It also provides support for variables.

Note that the parser is not a scripting language. There's no assignment operator and no control structures. Though it may simplify the parsing of a function and its parameters / arguments. Though you would actually use an actual function call syntax. So it may look like this

 "A(3):E():A(2)"

As said you still need to split your string at the colons before parsing each part. Though you could even parse something like

 "A(3+x):E(someVar * 3 + 5):A(2)"

Of course your code has to set the variable "x" and "someVar" but it will be picked up and used when the methods are called. In the end each part would just yield an expression that when evaluated will call the method as a side effect ^^. You can register / add as many functions as you like to the parsing context of the parser. Each parsed expression an expression context which manages the variables for a parsed expression. By default that context is shared between multiple expressions. The parsed expression has some convenient indexers to simplify the setting of variables.

So here's a simple example. Of course, after we added the file to the project we have to include the namespace "B83.LogicExpressionParser" when we want to use the Parser.

 using B83.LogicExpressionParser;
 
 // [ ... ]
 
 Parser parser;
 
 void Awake()
 {
     parser = new Parser();
     parser.ParsingContext .AddFunction("A", MethodA);
     parser.ParsingContext .AddFunction("E", MethodE);
 }
 
 double MethodA(ParameterList aParams)
 {
     Debug.Log("Method A: " + aParams[0]);
     return 0;
 }
 double MethodE(ParameterList aParams)
 {
     Debug.Log("Method E");
     return 0;
 }
 
 List<LogicExpression> ParseCommandString(aString)
 {
     var parts = aString.Split(':');
     var result = new List<LogicExpression>();
     foreach(var part in parts)
     {
         result.Add(parser.Parse(part));
     }
     return result;
 }

So this would be the basic outline. You can now call "ParseCommandString" with your command string like this

 List<LogicExpression> list = ParseCommandString("A(3):E():A(2)");

and you get a list of all individual expressions that can be evaluated at will. For example just doing this:

 foreach(var exp in list)
 {
     exp.GetResult();
 }

Will execute the methods specified in the string in order one after another.

In order to use variables you can just set the value of those variable before you call GetResult on an expression:

 exp["x"] = 5;
 exp.GetResult();

This will use the value 5 in place where "x" was used in the expression. Since by default all expressioned parsed by the same Parser share the same expression context, you can set the values for the variables once

 parser.ExpressionContext["x"] = 5;

Since the custom expression tree internally references the variable in the context, changing a variable and calling GetResult again will use the new value.

Though I guess this was all out of scope of the original question ^^. I've written the LogicExpressionParser for the parametric L-System I've written for this question in order to parse the conditions, just if someone is interested.

I am writing this off the top of my head directly in the answer, so it hasnt been tested, but should get you on the right track. This is the easiest was I could think to do this.

 string CommandString="A3:E:A2";
 
 public void ParseCommands()
 {
     string[] Commands = CommandString.Split(':');
 
     foreach (String s in commands)
     {
         switch (s[0])
         {
             case "A":
                   MethodA(int.parse(S[1]);
                   break;
 
             Case "E":
                   MethodE();
                   break;
         }
     }
 }

This should at least get you a start.

I wont say this is the absolute best way to do this, but it is the easiest way I could think of.

Hope it helps, -Larry

Here's my implementation, using a dictionary to store delegates instead. This scales better than a large switch-case structure if you've got a lot of methods:

     class MethodString
     {
         public readonly string CommandString;
 
         delegate void Command(int i);
         Dictionary<char, Command> Commands;
 
         public MethodString(string seed)
         {
             CommandString = seed;
 
             InitializeActions();
             CallActions();
         }
 
         void InitializeActions()
         {
             Commands = new Dictionary<char, Command>()
             {
                 { 'A', MethodA },
                 { 'E', MethodE }
             };
         }
 
         void CallActions()
         {
             string[] commands = CommandString.Split(':');
 
             foreach (var command in commands)
             {
                 var action = Commands[command[0]];
                 action.Invoke(int.Parse(command[1].ToString()));
             }
         }
 
         void MethodA(int i)
         {
             // Do smt
             Console.WriteLine(i + ": from A");
         }
 
         void MethodE(int i)
         {
             // Do smt else
             Console.WriteLine(i + ": from E");
         }
     }

And you call it like this:

 void Start()
 {
      new MethodString("A3:E2:A4");
 }