From FlexRule Wiki
Jump to: navigation, search


An expression is a combination of explicit values, variables, operators, and functions that are evaluated according to particular rules and then produce new values.

For evaluating an expression ExpressionEval should be used. If a variable is required an instance of VariableContainer must be passed.

Expression is the building block of writing rules and conditions. There are some other models (e.g., Decision Table) that support more expression formats as well as normal expressions.

Evaluating Expression in Code

Here is an example of how you can evaluate an expression containing some variables:

  1. var variables = new VariableContainer();
  2. variables.RegisterVariable("x");
  3. variables.RegisterVariable("y");
  4. variables.RegisterVariable("result");
  6. variables["x"] = 5;
  7. variables["y"] = "a test string";
  9. var res = ExpressionEval.Default.Compute(variables, "result = (x lt 3) ? x : (x+y.Length)");
  10. // res, variables["result"] are both equal to 18


Value is an expression that cannot be evaluated any further. The evaluation engine can process the following value types:

Type Format Sample
String "test string value"
Integer Suffix i 23i
Decimal Suffix m 67m
Double Suffix d 0d
Long Suffix l 20l
Boolean true false
null null
DateTime # date_time_string # #23-04-2009 3:9 pm#
DateTime with Format specifier # date_time_string | formatter_string # #23-04-2009 | dd-MM-yyyy#
TimeSpan #{day.hour:minute:second}# #{3:45}#
Array [value1, value2,... ] [1,2,'test',4]
Dictionary { key1:value1, key2:value2... } {person: {name:'Joe', age:10}}

For the DateTime Format specifier, please visit Format specifier


Variables can be defined with a name,

  • Short variable name: alphabetic numeric _ $
    • x
    • abc3
    • point_x
    • $value
  • Long variable name: { variable name }
    • {applicant name}
    • {risk factor}
    • {person's father name}

Variables in different logic are defined as parameters. You can define them in the following types of rules and logic:

  • Procedural rules
  • Flow logic
  • Validation rules
  • Workflow logic
  • Inference rules
  • Decision


All the execution routing conditions in the rules and logic are based on a expression evaluation. An expression is shown below:

Mathematical operators

Name Sign Sample
Addition + 23+4
Subtraction - 2.1-5.76
Division / 34/8
Multiplication * 3*6.9
Modulus  % 7%2
Power ** 2**3

Assignment operator

Name Sign Sample
Assignment = x=y.GetCordinate().X/2

Assignment operator format:

expression = expression 

In this case, the left-hand-side expression must finish with a Property or Field of an object

variable = expression

Boolean operators

Name Sign Sample
And &&
(age<18) && (i>10)
(age<18) and (i>10)
Or ||
(Age lt 15) || (Male==true)
(Age lt 15) or (Male==true)
Negate !
 !(Age lt 15)

Please note you MUST use parentheses around both sides of a boolean operator to make sure you prioritize the evaluation on the left and right side of the boolean operator.

Comparing operators

Name Sign Sample
Equality ==
Inequality  !=
Gender != Female
Less than <
(Age < 15)
(Age lt 15)
Smaller than or equal <=
(Age <= 15)
(Age le 15)
Greater than >
(Age > 15)
(Age gt 15)
Greater than or equal >=
(Age >= 15)
(Age ge 15)

Case insensitive

Name Sign Sample Result
Equality ===
'test'==='TEST' true
Inequality  !==
'abce' !== 'Abcd' false

Priority operator

Sub-expression evaluation based on priority:

  • Begin (
  • End )

Object members operators

Access to objects (variable) members:

  • Method (.)
  • Property (.)
  • Indexer, Array, list item access ([) and (])

Condition operator

Inline condition operator
Name Sign Sample
Condition  ?
Alternatives  : 2.1-5.76

For example:

(3==4)?'this is cool':'what are you talking about?'

The alternative of an inline condition operator is use if-then-else format:

if condition then result else other-result

For example, the above example can be written as:

if 3==4 then 'this is cool' else 'what are you talking about?'

Also, they can be nested:

if Product Type == 'STANDARD LOAN'
then 20.00d
else if Product Type == 'SPECIAL LOAN'
then 25.00d
else null


When a variable is defined, then the method of the variable can be called using . operator, and parenthesis are required at the end of the method and input arguments are comma separated.

Example: Assume x and b are defined parameter, then expression 'x.Calculate(2i ,b)' calls Calculate method of the x and passes integer 2 and variable b as input arguments.


Functions are very similar to methods, but the difference is they do not belong to any specific variable. They are global in the whole expression evaluation context. For example, let's consider the following expression:

in(age, array(3,4,56,60,3,10))

As you can see in and array are accepting arguments with parentheses, and they are comma separated, exactly like methods. But there is no . operator involved. Functions can be defined at the application/rule level and they are a way to extend the functionality at the expression evaluation level.

Please check API for built-in functions.

Decision Table Expressions

In a Decision Table there are some more expression formats that can be used to simplify the value-based rules. In general, when a value is entered in a data section of a Decision Table, it dynamically resolves its type based on the column type and template expression.

Type of Value Sample Expression description
Negate not: 2-3-4 Prefix with not:
String blah blah blah
Explicit String "blah blah blah" or 'blah...' String quotes (double or single)
Numbers 23 or 4i or 3.4d No prefix (all expression rules in above sections apply)
Expression  : applicant.GetLastAttendanceDate()  :
Range [23, 45]
(43, 50)
[1 .. 456)
Square brackets [] for inclusion and Parentheses exclusion in value ranges and they are comma (,) or semicolon (;) or double dot (..) split.
Multi-Values 12,3,4

34,3d,'string value', true, var2.Length
Multi values are ',' split. They can be combination of different values and variable references.

For example, in the second example we have have defined multiple values as 34 (integer number), 3.0 (decimal number), true (boolean value) and var2.Length (as Length property of a variable reference named var2)

Note: Multi values must explicitly specify their types on each element separated by comma.



(a+b)+(2 * c)-d


a < 10
(a+b) gt 23


a = b + c
str = 'hello FlexRule expressions'

Storing the result of comparison into 'r'

r = (b+c)<d

Method Call: i.e. obj is an object reference which is not null

a = obj.CalculateSum()+20-b

Access Property:

 b = obj.Name + '-' + obj.Family


Pipes are types of function that you can chain together and pass previous results to the next one.

|pipeName (arg1, arg2, arg3...)

For example, the result of people |count() is an integer that is the length of the people list. In this example, the count function receives people as its input and its result as a number (integer).

  1. var list = new List<DecisionAgeTests.Person>()
  2. {
  3.     new DecisionAgeTests.Person("arash", 38, DecisionAgeTests.Gender.Male),
  4.     new DecisionAgeTests.Person("Parsa", 6, DecisionAgeTests.Gender.Male),
  5.     new DecisionAgeTests.Person("Pooya", 3, DecisionAgeTests.Gender.Male),
  6.     new DecisionAgeTests.Person("Shah", 3, DecisionAgeTests.Gender.Female)
  7. };
  9. var vc = new VariableContainer();
  10. vc.RegisterVariable("people", list);
  12. var res = ExpressionEval.Default.Compute(vc, "people |count ()");
  14. Assert.AreEqual(list.Count, (int)res);

Learn more about list of pipes


When you are working with XML-based data/information, you need to read and manipulate XML. For more details, visit Xml API help