FunctionalDev.ExpressionHelpers 2.0.0

FunctionalDev.ExpressionHelpers

Expression Helpers is a library which has been created to enable lambda expression serialisation and deserialisation.

With the help of this library, it is possible to convert from and to string literal representations of expression trees.

For example, (Person person) => Person.FirstName == "Fred" can be converted to "FirstName = 'Fred'" and vice versa.

This typically benefits two key areas of programming, configuration and dynamic API queries. Configuration can be enhanced allowing Expression<Func<T, bool>>/Func<T, bool> types to be read from configuration.

Dynamic API queries can be implemented by enabling something along the lines of IEnumerable<T> GetModels<T>(Expression<Func<T, bool>> filter); in the client library and having the API dynamically execute the query, unlocking significant performance and extension benefits. This could be taken further and executed in a Linq to SQL layer if an ORM such as Entity Framework is in use.

String Literal Breakdown

A string literal, in the context of this library, is a string which represents a serialised lambda expression. This can be broken down into segments which represent boolean conditions, chained together with chaining operators.

A string literal is built up with the following for constant/member evaluation. Members and constants can exist either side of the equation.

Constant values must be wrapped in single quotes, this denotes the internal expression as a constant value. "{Member/Constant} {Evaluation Symbol} {Member/Constant}" Methods can also be used. "{Member}.{Method Name}({Arguments as comma separated literals})" Note that nullable types and null avoidance are handled in deseralisation.

Evaluation Symbols

The following comparisons are possible.

Chaining Operators

Examples

For the following class, some examples are listed below.

public class Person
{
	public string FirstName { set; get; }
	public int Age { set; get; }
	public IEnumerable<Person> Friends { set; get; }
}

var basicMemberLiteral = "FirstName = 'Fred'";
var alternativeMemberLiteral = "'Fred' = FirstName";
var numericalLiteral = "Age = '51'";
var methodLiteral = "FirstName.Contains('F')";
var nestedLambdaMethodLiteral = "Friends.Any(Age = '50')";
var chainedAndLiteral = "Friends.Any(Age = '50') And FirstName = 'Fred'";
var chainedOrLiteral = "Friends.Any(Age = '50') Or FirstName = 'Fred'";
var chainedComplexLiteral = "(Friends.Any(Age = '50') Or FirstName = 'Fred') And Age = '60'";
var nullLiteral = "FirstName = null";

Examples Calling Parser

// As expression.
Expression<Func<Person, bool>> parsed = ExpressionParser.Parse<Person>("FirstName = 'Fred');
// As Func.
Func<Person, bool> parsed = ExpressionParser.Parse<Person>("FirstName = 'Fred').Compile();

// literal will contain the value "Firstname = 'Fred'".
var literal = ExpressionParser.Parse((Person x) => x.FirstName == "Fred");

Also note that ExpressionParser contains non generic method alternatives for when the type is not known at compile time.

Remarks

Null comparisons are supported with the following syntax "FirstName = null".

Limitations/Future Development

TBC.