More examples using Rule Builder

[jose....@gmail.com]

I was wondering if you have ANY examples whatsoever of Grouping Patterns utilizing the Rule Builder (building rules dynamically) similar to the ones displayed here: https://github.com/NRules/NRules/wiki/Fluent-Rules-DSL .
I have been playing around with your example: https://github.com/NRules/NRules/wiki/Rule-Builder, and also the one included in the source code, but cannot extrapolate the concepts well.

I am specifically trying to figure out how to control the flow of conditions within a rule ('Or' instead of 'And', etc), and also how to fire distinct actions depending on the output from the condition.

Any help/direction would be appreciated.  

Thank you!

[Sergiy Nikolayev]

I'm currently traveling, so I'll post an example when I get back next week.

For now, you can look at the source code behind fluent rules, since they are internally using RuleBuilder. https://github.com/NRules/NRules/blob/develop/src/NRules/NRules.Fluent/Expressions/LeftHandSideExpression.cs

[jose....@gmail.com]

Thank you for the link! This will help me get a grasp on it better.  Thank you!

[Sergiy Nikolayev]

Here is a modified example from the RuleBuilder sample, that uses an OR group on the left-hand side of the rule:

//Create rule builder
var builder = new RuleModel.Builders.RuleBuilder();
builder.Name("TestRule");

//Customer pattern
PatternBuilder customerPattern = builder.LeftHandSide().Pattern(typeof (Customer), "customer");
Expression<Func<Customer, bool>> customerCondition =
    customer => customer.Name == "John Do";
customerPattern.Condition(customerCondition);


//OR group
var orGroup = builder.LeftHandSide().Group(GroupType.Or);

//Order pattern 1
PatternBuilder orderPattern1 = orGroup.Pattern(typeof (Order), "order");
Expression<Func<Order, Customer, bool>> orderCondition11 =
    (order, customer) => order.Customer == customer;
Expression<Func<Order, bool>> orderCondition12 =
    order => order.Amount > 100.00m;
orderPattern1.Condition(orderCondition11);
orderPattern1.Condition(orderCondition12);

//Order pattern 2
PatternBuilder orderPattern2 = orGroup.Pattern(typeof (Order), "order");
Expression<Func<Order, Customer, bool>> orderCondition21 =
    (order, customer) => order.Customer == customer;
Expression<Func<Order, bool>> orderCondition22 =
    order => order.Amount < 10.00m;
orderPattern2.Condition(orderCondition21);
orderPattern2.Condition(orderCondition22);

//Build actions
Expression<Action<IContext, Customer, Order>> action =
    (ctx, customer, order) => Console.WriteLine("Customer {0} has an order in amount of ${1}", customer.Name, order.Amount);
builder.RightHandSide().Action(action);

The idea is that when you want to group conditions using OR group, you first need to create a group, and then add patterns to it.

[Benjamin Pullicino]

I am trying to create a more complex dynamic rule

(Condition1 OR Condition2) AND Condition3

Would it be possible to post an example on how to do this?

[fredzy]

@Sergiy Nikolayev

I want to create a UI where user can define a complex rules. The idea is to add a grammar for validation of the rule syntax that the users will define on the UI and then pass this rule to the RuleBuilder some how which will execute it on the go.

Is it possible with RuleBuilder? Any examples would be highly appreciated.

Thanking in anticipation.

[Sergiy Nikolayev]

While this is a very late response, maybe others are also interested in this. NRules.Language is doing exactly what's described in the question - custom grammar is defined using ANTLR, which is then parsed and converted to NRules rule via RuleBuilder. The rules using this language can be written in some sort of custom UI, stored in a DB or a text file, and then later fed to the parser to convert to the NRules structure and then compiled to the executable model.

[Seva]

Hi,

Can you post an example of a complex rule achieved with RuleBuilder Please?

For example:

Condition1 AND Condition2 AND (Condition3 OR Condition4)

or

(Condition1 OR Condition2) AND Condition3

Seems like i have don't fully understand how patterns works

Thanks