Build XML based Business Rule Engine in .NET 4 – Post 3 (write runtime condition predicate)

It is continuation of first post - << click here to read
and second post - < click here to read

Dynamicity is of great advantage. First of all let us move forward step wise, define delegate to a separate method;

rule.AddCondtion(po => po.NetProductPrice >= 0);

should tends to

rule.AddCondtion(IsPriceGreaterOrEqualToZero());

public static Predicate<PriceObject> IsPriceGreaterOrEqualToZero()

{

    return delegate(PriceObject po) { return po.NetProductPrice >= 0; };

}

Let us consider even more generic function to write. Point is every condition returns  Predicate<PriceObject> and internally the condition result is a Boolean variable (true/false). Why not create runtime generic delegate to handle Equals operator for example. We will make it compatible to other operators later.

public static Predicate<T> GetConditiPredicate<T>(string fieldName, string operatorName, string value)

{

    Type itemType = typeof(T);

    ParameterExpression predParam = Expression.Parameter(itemType, "po");

    PropertyInfo propertyInfo = itemType.GetProperty(fieldName);

    Expression left = Expression.Property(predParam, propertyInfo);

    Expression right = Expression.Constant(ObjTypeConverter.ChangeType(value, propertyInfo.PropertyType), propertyInfo.PropertyType);

    Expression equality = Expression.GreaterThanOrEqual(left, right);

    Func<T, bool> function = (Func<T, bool>)Expression.Lambda(equality, new[] { predParam }).Compile();

    return new Predicate<T>(function);

}

And caller can deliver a call like this

rule.AddCondtion(Dynamic.GetConditiPredicate<PriceObject>("DRM", "Equals", "2"));

Well compile and see if it works fine. It should :)

Now let us replace the statement with more general one….

//Expression equality = Expression.GreaterThanOrEqual(left, right);

Expression result = GetExpression(operatorName, left, right);

Func<T, bool> function = (Func<T, bool>)Expression.Lambda(result, new[] { predParam }).Compile();

And

public static Expression GetExpression(string operatorName, Expression left, Expression right)

{

    Expression result = null;

    switch (operatorName.ToLower())

    {

        case "equals":

            result = Expression.Equal(left, right);

            break;

        case "greaterorequal":

            result = Expression.GreaterThanOrEqual(left, right);

            break;

        case "lessorequal":

            result = Expression.LessThanOrEqual(left, right);

            break;

        case "greaterthan":

            result = Expression.GreaterThan(left, right);

            break;

        case "lessthan":

            result = Expression.LessThan(left, right);

            break;

        case "add":

            result = Expression.Add(left, right);

            break;

        case "subtract":

            result = Expression.Subtract(left, right);

            break;

        case "multiply":

            result = Expression.Multiply(left, right);

            break;

        case "divide":

            result = Expression.Divide(left, right);

            break;

        default:

            throw new Exception("Unknown Operator Name");

    }

    return result;

}

           

 This was simple to handle isolated conditions. How to handle Actions that may depend one another give us new dimension.

If want to play with Rule Engine source code - I extracted from my business case for demo purpose. download from skydrive. (FileName: ConfigurableRuleEngine.zip)
Comments please