TagBites.Expressions 1.2.0

TagBites.Expressions

TagBites.Expressions is a Roslyn-based C# expression parser and evaluator for .NET. It compiles runtime string expressions into strongly typed Func<> delegates or LambdaExpression expression trees, without creating a new assembly.

var options = new ExpressionParserOptions { Parameters = { (typeof(int), "a"), (typeof(int), "b") } };
var func = ExpressionParser.Compile<Func<int, int, int>>("(a + b) / 2", options);
int r = func(2, 4); // 3

Because Roslyn does the parsing, expressions use real C# syntax: operators, precedence, numeric promotion, implicit conversions, pattern matching, tuples, lambdas, LINQ and generics behave like they do in the C# compiler. If C# accepts the expression, TagBites.Expressions accepts it; if C# rejects it, so does the parser.

Try it online — type an expression and evaluate it in the browser.

Install

dotnet add package TagBites.Expressions

Targets netstandard2.0. Only dependency is Microsoft.CodeAnalysis.CSharp.

Usage

Evaluate once:

ExpressionParser.Invoke("5 / 2.5");                              // 2d
ExpressionParser.Invoke<int>("new [] { 1, 2, 3 }.Sum()");        // 6
ExpressionParser.Invoke<int>("(a + b) / 2", ("a", 2), ("b", 4)); // 3

Compile once, run many times:

var options = new ExpressionParserOptions { Parameters = { (typeof(double), "x"), (typeof(double), "y") } };
var func = ExpressionParser.Compile<Func<double, double, double>>("Math.Pow(x, y) + 5", options);
func(2, 10); // 1029
func(2, 2);  // 9

Bind an object as this:

var options = new ExpressionParserOptions
{
    Parameters = { (typeof(TestModel), "this") },
    UseFirstParameterAsThis = true
};

ExpressionParser.Invoke("X + Y", options, new TestModel { X = 1, Y = 2 }); // 3

Expose named values and delegates with GlobalMembers:

var options = new ExpressionParserOptions
{
    Parameters = { (typeof(int), "a") },
    GlobalMembers = { { "b", (null, 2) } }
};

var func = ExpressionParser.Compile<Func<int, int>>("a switch { 1 => b, 2 => b * 2, _ => b + a }", options);
func(3); // 5

String interpolation, including alignment and format specifiers (formatting follows the current culture):

ExpressionParser.Invoke(@"$""sum = {1 + 2}""");                          // sum = 3
ExpressionParser.Invoke(@"$""{5,-4}|""");                                // "5   |"   (left aligned)
ExpressionParser.Invoke(@"$""{5,6:000}""");                              // "   005"  (alignment + format)
ExpressionParser.Invoke(@"$""{255:X}""");                                // FF
ExpressionParser.Invoke(@"$""{new DateTime(2021, 8, 14):yyyy-MM-dd}"""); // 2021-08-14
ExpressionParser.Invoke(@"$""{(1 < 2 ? ""yes"" : ""no"")}""");           // yes

Anonymous objects (new { ... }) work like a real anonymous type without generating a new one, by internally mapping it to DynamicObject:

var script = "new[] { 1, 2, 3 }.Select(v => new { Value = v, Doubled = v * 2 }).Sum(v => v.Value + v.Doubled)";
dynamic result = ExpressionParser.Invoke(script);
Console.WriteLine(result); // 18

Get the expression tree, or parse without throwing:

LambdaExpression lambda = ExpressionParser.Parse("x * 2 + 1", options);

if (!ExpressionParser.TryParse("a + ", options, out var expr, out var error))
    Console.WriteLine(error);

FastExpressionCompiler

ExpressionParser.Parse() returns a plain LambdaExpression, so it can be compiled with any compiler instead of the built-in Compile(). FastExpressionCompiler is a drop-in, dependency-free replacement for LambdaExpression.Compile() that produces the same delegate much faster:

dotnet add package FastExpressionCompiler

using FastExpressionCompiler;

var lambda = ExpressionParser.Parse("Math.Pow(x, y) + 5", options);
var func = (Func<double, double, double>)lambda.CompileFast();

Benchmark

The more complex the expression tree, the bigger the gap, since most of the reflection-emit overhead Compile() pays per node is avoided by CompileFast().

Benchmark source: CompileToDelegate.cs.

Use cases

Use TagBites.Expressions when you need to parse, validate, evaluate or compile C# expressions from strings at runtime:

• dynamic business rules and predicates
• user-defined formulas and calculations
• configurable filters and scoring logic
• compile-once/run-many Func<> delegates
• LambdaExpression trees for expression-based APIs
• LINQ-style runtime logic with real C# expression syntax

Why TagBites.Expressions?

• Real C# expression syntax — parsed by Roslyn, not by a custom C#-like grammar.
• Runtime expression evaluation — evaluate once or compile once and invoke many times.
• Delegates or expression trees — compile to Func<> delegates or parse to LambdaExpression.
• Modern C# expressions — supports LINQ, lambdas, pattern matching, switch expressions, tuples, generics, interpolated strings, etc.
• No generated assembly — expressions are compiled without creating a new assembly.

Supported C# expression syntax

• Operators: arithmetic, bitwise, shifts, comparison, && || !, ?:, ??, ?./?[], is/as, x!.
• Literals: all numeric types, char, string, verbatim and interpolated strings, hex, digit separators.
• Members and calls: properties, fields, indexers (including index-from-end x[^1]), generic and extension methods, params.
• new: constructors, object and collection initializers, arrays (jagged, multidimensional and sized), target-typed new().
• Anonymous objects (new { X = 1, Y = 2 } — see Usage above).
• Lambdas and LINQ (Select, Where, GroupBy, ...), including nested and multi-argument lambdas.
• Tuples, including element-wise equality.
• typeof, default(T), nameof, sizeof, checked, unchecked.
• Pattern matching in is and switch: type, constant, relational, and/or/not, property, positional and var patterns, when guards.

Statements (like if), async/await, and declarations (methods, types) are out of scope - this is an expression parser.

Not currently supported:

• The range operator (1..2, arr[1..^1]).

Configuration

ExpressionParserOptions:

Result type:
ResultType is a contract: the expression must produce this type. A C# implicit conversion (like int → long) is applied automatically; anything else is a parse error. Use it to require, for example, that a filter is a bool.
ResultCastType forces the return type with an explicit cast, so unrelated expressions can share one delegate signature. It also allows casts that are not implicit, such as double → int.

The two combine: to run many rules through a single Func<object> while still requiring each to be boolean, set ResultType = typeof(bool) (reject anything non-boolean) together with ResultCastType = typeof(object).

Non-standard options:
These opt-in options (all default to false) make the parser accept syntax or semantics that real C# does not:

Alternatives

TagBites.Expressions fits between lightweight expression evaluators and full C# scripting engines: it supports real C# expression syntax through Roslyn, returns delegates or expression trees, and avoids generating a new assembly.

C# syntax vs DynamicExpresso

Because TagBites parses with Roslyn, it accepts modern C# syntax that DynamicExpresso's own parser does not.
Verified against DynamicExpresso 2.19.3 (see LibraryFeatureComparer.cs):

Both handle arithmetic and logical operators, member access, method calls, generics, lambdas and LINQ, is/as, typeof, default(T), object initializers, ternary and null-coalescing/-conditional.

Benchmark

Parsing "Math.Pow(x, y) + 5" into a LINQ expression. TagBites (v. 1.1.0) vs DynamicExpresso (v. 2.19.3).

Benchmark source: ParseToExpression.cs.

Links

• Changelog
• Security policy
• License (MIT)