LinqExpressions are used to create a MicroRuleEngine.

.net c# expression-trees linq

Question

So I am building a MicroRuleEngine (Would love to see this take off as an OpenSource project) and I am running into a null reference Error When executing the compiled ExpressionTree and I am not exactly sure why. Rules against the simple properties work but going against Child Properties aka Customer.Client.Address.StreetName etc. do not work.

Below is the MicroRuleEngine

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;

namespace Trial
{
    public class MicroRuleEngine
    {
        public bool PassesRules<T>(List<Rule> rules, T toInspect)
        {
            bool pass = true;
            foreach (var rule in rules)
            {
                var cr = this.CompileRule<T>(rule);
                pass = pass && cr.Invoke(toInspect);
                if (!pass)
                    return pass;
            }
            return pass;
        }
        public Func<T, bool> CompileRule<T>(Rule r)
        {
            var paramUser = Expression.Parameter(typeof(T));
            Expression expr = BuildExpr<T>(r, paramUser);
            // build a lambda function User->bool and compile it

            return Expression.Lambda<Func<T, bool>>(expr, paramUser).Compile();
        }

        Expression BuildExpr<T>(Rule r, ParameterExpression param)
        {
            Expression propExpression;
            Type propType;// typeof(T).GetProperty(r.MemberName).PropertyType;
            ExpressionType tBinary;
            if (r.MemberName.Contains('.'))
            {
                // support to be sorted on child fields.
                String[] childProperties = r.MemberName.Split('.');
                var property = typeof(T).GetProperty(childProperties[0]);
                var paramExp = Expression.Parameter(typeof(T), "SomeObject");
                propExpression = Expression.MakeMemberAccess(paramExp, property);
                for (int i = 1; i < childProperties.Length; i++)
                {
                    property = property.PropertyType.GetProperty(childProperties[i]);
                    propExpression = Expression.MakeMemberAccess(propExpression, property);
                }
                propType = propExpression.Type;
                propExpression = Expression.Block(new[] { paramExp }, new[]{ propExpression });

            }
            else
            {
                propExpression = MemberExpression.Property(param, r.MemberName);
                propType = propExpression.Type;
            }

            // is the operator a known .NET operator?
            if (ExpressionType.TryParse(r.Operator, out tBinary))
            {
                var right = Expression.Constant(Convert.ChangeType(r.TargetValue, propType));
                // use a binary operation, e.g. 'Equal' -> 'u.Age == 15'
                return Expression.MakeBinary(tBinary, propExpression, right);
            }
            else
            {
                var method = propType.GetMethod(r.Operator);
                var tParam = method.GetParameters()[0].ParameterType;
                var right = Expression.Constant(Convert.ChangeType(r.TargetValue, tParam));
                // use a method call, e.g. 'Contains' -> 'u.Tags.Contains(some_tag)'
                return Expression.Call(propExpression, method, right);
            }
        }

    }
    public class Rule
    {
        public string MemberName { get; set; }
        public string Operator { get; set; }
        public string TargetValue { get; set; }
    }
}

And This is the Test that is Failing

[TestMethod]
public void ChildPropertyRuleTest()
{
    Container container = new Container()
    {
        Repository = "TestRepo",
        Shipment = new Shipment() { OrderNumber = "555" }
    };

    MicroRuleEngine mr = new MicroRuleEngine();
    var rules = new List<Rule>() { new Rule() { MemberName = "Shipment.OrderNumber", Operator = "Contains", TargetValue = "55" } };
    var pases = mr.PassesRules<Container>(rules, container);
    Assert.IsTrue(!pases);
}
1
1
4/28/2013 4:16:22 AM

Fastest Entity Framework Extensions

Bulk Insert
Bulk Delete
Bulk Update
Bulk Merge

Accepted Answer

So the error I was running into was all the examples I read in trying to find out how to access sub properties were using MemberAccess Expressions to walk down the properties and I found that using PropertyExpressions worked without a problem for the simple tests I have. Below is an update that is now working

public class MicroRuleEngine
    {
        public bool PassesRules<T>(List<Rule> rules, T toInspect)
        {
            return this.CompileRules<T>(rules).Invoke(toInspect);
        }
        public Func<T, bool> CompileRule<T>(Rule r)
        {
            var paramUser = Expression.Parameter(typeof(T));
            Expression expr = BuildExpr<T>(r, paramUser);

            return Expression.Lambda<Func<T, bool>>(expr, paramUser).Compile();
        }

        public Func<T, bool> CompileRules<T>(IList<Rule> rules)
        {
            var paramUser = Expression.Parameter(typeof(T));
            List<Expression> expressions = new List<Expression>();
            foreach (var r in rules)
            {
                expressions.Add(BuildExpr<T>(r, paramUser));
            }
            var expr = AndExpressions(expressions);

            return Expression.Lambda<Func<T, bool>>(expr, paramUser).Compile();
        }

        Expression AndExpressions(IList<Expression> expressions)
        {
            if(expressions.Count == 1)
                return expressions[0];
            Expression exp = Expression.And(expressions[0], expressions[1]);
            for(int i = 2; expressions.Count > i; i++)
            {
                exp = Expression.And(exp, expressions[i]);
            }
            return exp;
        }

        Expression BuildExpr<T>(Rule r, ParameterExpression param)
        {
            Expression propExpression;
            Type propType;
            ExpressionType tBinary;
            if (r.MemberName.Contains('.'))
            {
                String[] childProperties = r.MemberName.Split('.');
                var property = typeof(T).GetProperty(childProperties[0]);
                var paramExp = Expression.Parameter(typeof(T), "SomeObject");

                propExpression = Expression.PropertyOrField(param, childProperties[0]);
                for (int i = 1; i < childProperties.Length; i++)
                {
                    property = property.PropertyType.GetProperty(childProperties[i]);
                    propExpression = Expression.PropertyOrField(propExpression, childProperties[i]);
                }
                propType = propExpression.Type;
            }
            else
            {
                propExpression = Expression.PropertyOrField(param, r.MemberName);
                propType = propExpression.Type;
            }

            // is the operator a known .NET operator?
            if (ExpressionType.TryParse(r.Operator, out tBinary))
            {
                var right = Expression.Constant(Convert.ChangeType(r.TargetValue, propType));
                // use a binary operation, e.g. 'Equal' -> 'u.Age == 15'
                return Expression.MakeBinary(tBinary, propExpression, right);
            }
            else
            {
                var method = propType.GetMethod(r.Operator);
                var tParam = method.GetParameters()[0].ParameterType;
                var right = Expression.Constant(Convert.ChangeType(r.TargetValue, tParam));
                // use a method call, e.g. 'Contains' -> 'u.Tags.Contains(some_tag)'
                return Expression.Call(propExpression, method, right);
            }
        }

    }
    public class Rule
    {
        public string MemberName { get; set; }
        public string Operator { get; set; }
        public string TargetValue { get; set; }
    }
1
9/9/2011 6:57:53 PM

Popular Answer

Don't supposed you've had a look at the dynamic expression parser which was bundled as an example project for the VS2008 samples. It includes a type called an ExpressionParser which can be used to convert string expressions to Expression instances. I've used this previously to turn string expressions into compilable delegates, e.g, I could do something like:

string expression = "(1 + 2)";
var func = FunctionFactory.Create<int>(expression);

int result = func(1, 2); // Result should be 3.

...where FunctionFactory is a wrapper around the ExpressionParser type. I could also do:

expression = "(a * b)";
var func2 = FunctionFactory.Create<int, int, int>(expresion new[] { "a", "b" });

int result = func2(10, 50); // Result should be 500;

Or something a little tangible:

expression = "(Age == 5)";
var func3 = FunctionFactory.Create<Person, bool>(expression);

bool isFive = func3(new Person { Age = 5 });

Would this be of any use to you? You can read my blog article here.

Matthew Abbott

Related Questions

Using Expression and creating Expression Trees Method to invoke

I have two dummy classes named ...TClass1... and ...TClass2.... I would like to know how to build an expression tree to call the operation ...TClass1.TestMethod.... I specifically have problem using ...Expression.Call... method to create an expression based on instance methods of a class. Any help would be appreciated....public class TClass1 { ...
c# expression-trees
asked by Hamid Rashidi

Building an expression tree using a stack and a binary tree c

I am given an arithmetic formula containing operators +, -, *, / and parentheses (which might or might not change the natural precedence of operators). An example would be the following one: a / b + f – (c + d) * e – a * c. and I am asked to use a stack (implemented as a linked list) in order to keep track of the operands and the operators: an...
binary-tree c expression-trees stack
asked by user1680944

Building a custom predicate to act as a filter using a foreach loop

I don't understand why you do this:...innerPredicate = innerPredicate.Or(d => inPeriod.Invoke(d)); ...When you could just avoid the ...Invoke... completely, like this:...innerPredicate = innerPredicate.Or(inPeriod); ...This should work perfectly fine....BTW, I have a feeling there's a bug with LINQKit here (unless there's some documentation that su...
c# expression-trees linq-expressions linqkit linq-to-entities
asked by Ani

Building Expression Tree Using a Parameter's Indexer

Given a class that has a property that is a Dictionary...public class Product { public Dictionary<string, string> Attributes { get { return attributes; } } private Dictionary<string, string> attributes = new Dictionary<string, string>(); } ...I want to be able to match products in a list of products based on criteria that are retrieved fro...
c# expression expression-trees lambda linq
asked by John Kraft

Build Dynamic Select using Expression Trees

I know your main question is about building a dynamic linq expression tree, but I might be able to help with your secondary question about binding the Queryable to the grid. ...EDIT: Sorry, I actually tried this and doing OfType< object > generated a Casting exception, so here is something that will actually work ...var query = dataview.Provider.C...
c# entity-framework expression-trees linq-to-entities webforms
asked by Mike Peterson

Build expression tree for LINQ using List<T>.Contains method

Problem...I'm working on refactoring some ...LINQ... queries for several reports in our web application, and I'm attempting to move some duplicate query predicates into their own ...IQueryable... exension methods so we can reuse them for these reports, and reports in the future. As you can probably infer, I've already refactored the predicate for g...
c# entity-framework expression-trees linq
asked by Garrett Bates

Using PredicateBuilder to build query searching across multiple columns of Entity

Expression.NotEqual... is the binary operator ...!=.... Since your ...Contains... call is not a binary operator, there is no direct replacement for this....Instead, what you need to do is a method call of ...Contains.... So you first need to get the ...MethodInfo... object for the ...string.Contains... function....It should look like this:...var me...
c# entity-framework expression-trees predicatebuilder
asked by poke

Building dynamic query in a loop using Expression trees

I have a system that allows different criteria pertaining to Sales to be stored in the database. When the criteria are loaded, they are used to build a query and return all applicable Sales. The criteria objects look like this:...ReferenceColumn (The column in the Sale table they apply to)...MinValue (Minimum value the reference column must be)...M...
c# entity-framework expression-trees linq
asked by Valuator

Dynamic Lambda expressions for filter and sorting using children using c#

hello i follow the guide in ...https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/expression-trees/how-to-use-expression-trees-to-build-dynamic-queries... to create filter and sorting in my relation class, i need to filter and sort using the children column "Channel"...this is my base class...public class MeterTransaction : E...
c# ef-core-2.0 expression-trees lambda linq-expressions
asked by Terry Yulianto

Using Expressions to build Array.Contains for Entity Framework

Probably the most difficult part is to find ...MethodInfo... of the ....Contains()... method. You could use ...typeof(IEnumerable<string>).GetMethod(...).Where(...)..., but it is usually difficult to do it right for generic method with several overloads. This is a small trick that employs C# compiler to find the correct overload for you by creating...
c# expression-trees
asked by Ňuf

Fastest Entity Framework Extensions

Bulk Insert
Bulk Delete
Bulk Update
Bulk Merge
View more on Stack Overflow

Prime Library

Performance

Expression Evaluator

More Projects...
Licensed under: CC-BY-SA with attribution
Not affiliated with Stack Overflow
Licensed under: CC-BY-SA with attribution
Not affiliated with Stack Overflow