XPress: A Simple Truth Expression Language

Background#

How many times you needed a quick, simple method to create expressions in a Json or XML element value. and you wished there were an easy way to create dynamic expressions at compile time as a literal string to be compiled and evaluated at runtime using the same powerful CLR. Well, I have!

The need for string expressions that can be simply expressed at compile time by engineers or non-engineering business or support team, has been a recurring theme through out my career. Whether its is business rules, business teams needs to modify it and change it frequently at runtime. or operation rules that devops team would like to control at runtime without the need to make a new deployment.

Goals#

So, I rolled up my sleeves and created XPress. It came handy in many situations and i used it in different product and solution. I had a few goals in mind when I designed XPress:

• Simple, yet powerful.
• Contained as possible, as little dependencies as possible.
• Few to zero configurations.
• Purely written in C# and .net.
• Fast, and efficient.
• Generates an optimized cacheable .net expressions.
• Support all truth operators (Binary, Unary, Relational, and Conditional).
• Support basic data types int32, string, boolean, float.
• Support variable binding at runtime.
• Ability to check on null-ability.

How it works?#

PM> Install-Package XPress

XPress is simple, all you have to do after installing XPress package using nuget manager, is instantiating XpressCompiler, author XPress expressions, compile it, and execute it. here is a simple XPress sample code:

1
XpressCompiler _compiler = XpressCompiler.Default;
2

3
// Create and Compile Expression
4
var expression = "x gt y*2";
5
var compilationResult = _compiler.Compile(code);
6

7
// Create XpressRuntimeContext object with variable names and values
8
XpressRuntimeContext runtimeCtx = new XpressRuntimeContext() { { "x", "10" }, { "y", "9" } };
9

10
// Call compiled Func with runtime context
11
var result = compilationResult.Code(runtimeCtx);

As you can see, XPress language doesn’t need much. very little configuration to start and you’re good to go. If you notice I used XpressCompiler.Default a singleton compiler instance can be used quickly to compile expressions. But a compiler instance can be always instantiated through constructor.

1
XpressCompiler _compiler = new XpressCompiler();

The compiler class offers a single method Compile(string) taking an xpress expression and return a compilation result. The XpressCompilationResult object offers a boolean flag Compiled to indicate the success or failure of the compilation process, and a Log object of type ILogReader which can be used to get status on compilation process and debug the result. A particularly useful pattern after compilation process is to check the HasErrors flag, if true GetErrorMessages() and print it or log it.

1
if (compilationResult.Log.HasErrors)
2
{
3
    var errors = compilationResult.Log.GetErrorMessages();
4
    foreach(var error in errors)
5
    {
6
        Console.WriteLine(error);
7
    }
8
}

Finally, the compilation result object, will have a Code predicate of type Func<XpressRuntimeContext, bool> that is the optimized compiled .net expression tree for your string expression. it accepts XpressRuntimeContext which is simply a strongly typed dictionary of <string,string> to bind expression’s variables to runtime values. use the XpressRuntimeContext object to pass values to your variables. Code predicate just like any other .net Func can be cached and executed multiple time. the result of execution is a boolean.

Language Features#

1
var e = "y eq x+2*2-4/2";

1
var e1 = "true";
2
var e2 = "false";
3
var e3 = "9 gt 10";
4
var e4 = " 'Ahmed' eq 'ahmed'";

1
var e = " 'Ahmed' ne null";

1
var e = "x eq (1+2)";

1
var e = "x eq ('ahmed '+'elmalt')";

1
// boolean operands
2
var e1 = "not false";
3

4
// boolean variables, the value of x must be set to a boolean value at runtime or runtime error
5
var e2 = "not x";
6

7
// boolean expression
8
var e3 = "not ('a' eq 'b' and 9 gt 10)";

1
var e = "1 eq 4";

1
var e = "false or x lt 2";

1
var e = "(x ne null and x+1 gt 10) or (y ne null and (y*(5+1)-2) lt 5)";

What about performance?#

XPress is built to be fast and optimized to generated very efficient .net lambda expressions. the most expensive part of the process as you can expect is the compilation of expressions, but this phase needs to occur once, and the result can be cached for the lifetime of the application. on average Xpress compilation phase takes about ~120ms.

Find more information about XPress on project github repository. I will be blogging more in the future about the internals implementation of the language and its compiler.

XPress is distributed under MIT license. What are you waiting, give it a try and let me know what you think!

Happy Coding!