I've come across several expression evaluators on this site. They utilize several clever ideas to implement them, but each of them had their "gotchas". I needed one that was flexible (handled more than one data type), that didn't compile code (too slow and wasted resources), that worked (one couldn't handle any unary operator), and could be easily adapted for other needs.
Thus, I've developed a set of simple classes called
FunctionEval. These evaluators handle numeric, string, boolean, and datetime datatypes, and they support all the unary and binary operators available in C#. They also support functions (through the utilization of
FunctionEval class) and have the ability to add custom functions by attaching an event handler that fires when a function name is not found.
About the project files
Included in the project zip(s) are the .cs files that implement regular expressions, expression evaluation, and function evaluation. Also included is a console based tester application that will allow you to enter and manually test particular expressions.
Simply select the version of the project (VS 2005 or 2003) from the versions above.
The API is really simple. You have two main classes:
FunctionEval. Both utilize each other to evaluate functions in an expression, or expressions in function parameters.
ExpressionEval has a default constructor and a special constructor to initialize the
Expression property. Everything pretty much centers around the
Expression property, the
ClearVariable methods, the
AdditionalFunctionEventHandler event, and the
Evaluate() method. There are also some special evaluate methods (i.e.
EvaluateBool()) that return a specific data type.
The first time
Evaluate() is called, the object creates a graph of the expression to improve performance during subsequent calls of the
Evaluate() method. However, if the
Expression property changes, it will release the graph and form a new one the next time
Evaluate() is called. Therefore, if you are using a consistent expression with changing values, use the
SetVariable method so that it will not destroy the graph for the expression.
FunctionEval has a default constructor and a special constructor to initialize the
Expression property. Calling
Evaluate() will cause the object to find the first function in the
Expression property and return its evaluation. Calling the
Shared in VB)
Replace(string strInput) will cause the object to find all the functions in the input string, and replace them with their evaluations in the output (returned) string. (Note: I added a non-static parameter-less
Replace() method that does the same thing, but it uses the
Expression property as the source string.)
ExpressionEval class and the
FunctionEval class have a
public event for handing custom functions. This event fires if a function name in the expression string has no built-in function associated. The event is named
Expression strings are easy to construct. Standard operator precedence applies. (See C# documentation) Parenthesis work. The !, -, and ~ unary operators are functional. To call a function in the expression string use the following syntax:
$functioname(param1, param2, ...).
To get a list of the built-in functions, look at the
ExecuteFunction method in FunctionEval.cs.
Here are some examples of expression strings:
(1 + 1) * 17 / 3
$now() >= $today()
$pi() == $e()
"Today is " + $fmtdate($today(), "dddd, MMMM d, yyyy")
@(Variable1) == @(Variable2)
!true == false
- Valid unary operators:
- Valid binary operators:
- Parenthesis are evaluated first.
- E-notation (
7.511E-10) is allowed for numbers and...
- Hexadecimal as well (
- Expressions in the form @dt(mm/dd/yyyy hh:mm:ss (AM/PM)) will return a datetime datatype.
- Expressions in the form @ts([d.]h:m[:s[.ms]]) will return a timespan datatype. tokens in  are optional.
- Expressions in the form @(VariableName) will attempt to look up a variable set by
In the unit test project, you will see a lot of sample expressions. Here are some example codes for usage:
Construction and evaluation
ExpressionEval expr = new ExpressionEval("1+1");
object val = expr.Evaluate();
Creating a custom function handler
static void eval_AdditionalFunctionEventHandler(
object sender, AdditionalFunctionEventArgs e)
object parameters = e.GetParameters();
e.ReturnValue = "This Library Rocks!";
e.ReturnValue = "WWWWWWWWHHHHHAT? YEAYAH! OKAY!";
string ret = "";
foreach (object parameter in parameters)
ret += parameter.ToString();
e.ReturnValue = ret;
(sender as FunctionEval).SetVariable(
"" + parameters,
Using the tester application
Make sure the tester application is set as the startup project. Hit F5 to build and run. You will see a blank console screen. Type in an expression and hit Enter. Its evaluation will appear below it, otherwise an error will be displayed. Type "clr" to clear the console, and type "exit" to quit the application.
There is one issue that I am aware of. If you place two binary operators in a row, no error is returned. Instead, the first in the list is used, and the rest until the right operand (w/ or w/o unary operator) are ignored.
Example: (1 * + -1). This will ignore '+' and execute (1 * -1).
Note: I've improved the error handling to catch unused tokens and missing binary operators.
- Added timespan functionality and recognition: @ts([d].h:m[:s[.mmm]]).  indicates optional components.
- Added more robust error handling to catch unused tokens and missing binary operators.
- Completely updated the code libraries (and verified that it works with the release of VS2005 Pro) and description with bug fixes and modifications that I've been sending to those who had requested for it. Also updated the custom function handling event to .NET event standards. (with sender and eventarg params)
- Changed functionality so that upon first execution of an expression (with a created object, not the
Shared) method), it parses it and creates a graph. As long as the
Expression property is not changed, it will keep the graph and, subsequent calls to
Evaluate() will not parse the expression, but re-execute the graph.
- Also added a .NET 2003 ready .zip file.