Expressions

Expressions are a core mechanism in R-COM Gateway workflows, especially in Condition Action blocks, enabling dynamic evaluation of conditions and parameter values. They allow you to build logic directly into workflow actions without requiring a full script.

Unlike scripts, which are full lists of statements, an expression always produces a single return value of a defined type. This makes expressions ideal for use in condition blocks, action parameters, and variable mappings.

Where Expressions Are Used

Expressions in R-COM Gateway appear anywhere a workflow or Event Rules requires a value that is calculated at runtime instead of entered statically. They are the glue between incoming event data, workflow logic, and action outputs.

Key usage areas include:

• Condition Blocks: Used to evaluate a boolean expression that decides the execution path (e.g., whether to follow the True or False branch).

• Action Parameters: Many workflow actions allow parameters to be set dynamically. For example:

  • Constructing a URL string in an HttpRequest action.
  • Performing numeric calculations before storing a value in SetVar.
  • Applying filters in object queries.

• Variable Assignments: The SetVar action supports assigning expressions, letting you compute values from existing workflow context variables instead of hardcoding them.

• Event Rules Variable Mapping: When configuring an Event Rules, incoming event payload fields can be transformed using expressions before being passed to workflow parameters.

• Looping and Iteration Blocks: Actions like While or ForEach use expressions to determine conditions or to select items within lists and dictionaries.

• Custom scripts: Custom script executes scripts using the built-in R-COM Gateway Interpreter, and these scripts can leverage expressions to perform dynamic operations inside workflows.

In short, expressions let you embed business logic directly into workflow design without dropping into full scripting, balancing flexibility with simplicity.

Expression Types and Examples

Expressions follow a C#-like syntax and support a wide range of operations.

Suppose:

Variable	Type	Content
myInt	int	15
myString	string	Mat4711
myList	List<int>	1,1,2,3,5,8
myDic	Dictionary<string, string>	Name=Peter, Age=20

1. Conditional

1myInt > 10 ? "yes" : "no"

Returns "yes" if myInt is greater than 10, otherwise "no".

2. Logical Operators

1myInt > 10 OR myInt < 10   // true
2myInt > 10 AND myInt < 10  // false
3NOT(myInt > 10)            // false

Supported: AND, OR, NOT.

3. Equality and Comparison

1myString == "Mat4711"   // true
2myInt != 15             // false
3myInt >= 10             // true
4myInt <= 15             // false

Useful for condition checks.

4. Type Checks

1myInt is int       // true
2myInt is string    // false

Ensures type safety at runtime.

5. Mathematical Operations

1myInt + 10     // 25
2myInt * 10     // 150
3myInt % 6      // 3
4-myInt         // -15

Expressions support integer and decimal math.

6. String Operations

1myString + myString             // "Mat4711Mat4711"
2myString + myInt.ToString()     // "Mat471115"
3myString.Substring(2)           // "t4711"

Concatenation and string methods are supported.

7. Instantiation

1new list<string>                        // returns empty list (List<string>)
2new dictionary<string,object>           // returns empty dictionary (Dictionary<string,object>)

Useful for creating fresh collections at runtime.

8. Index Access

1myList[0]       // 1 (int)
2myList[1]       // 1 (int)
3myList[2]       // 2 (int)
4myDic["Name"]   // "Peter" (string)
5myDic["Age"]    // "20" (string)

Works with List<T> and Dictionary<TKey, TValue>.

9. Property Access

1myString.Length   // 7 (int)
2myList.Count      // 6 (int)

Directly retrieves object or collection properties.

10. Method Calls

1myInt.ToString()             // "15" (string)
2myString.PadLeft(10)         // "   Mat4711" (string)
3myString.PadLeft(10, "0")    // "000Mat4711" (string)
4myString.Substring(2)        // "t4711" (string)

Instance methods are supported on primitive and collection types.

String Split Methods

The SplitLength and SplitPart methods allow you to split strings and access specific parts:

1TOPIC.SplitPart("/", 1) == "1234"        // access part at index
2TOPIC.SplitLength("/") >= 2 AND TOPIC.SplitPart("/", 1) == "1234"  // safe check with length

info

Use SplitLength to check the split result count before calling SplitPart to prevent index out of range errors.

11. Variable Access

1myInt       // 15 (int)
2myString    // "Mat4711" (string)

12. Function Calls

1DateTimeUtcNow()   // current UTC time (DateTime)
2NewGuid()          // random UUID (Guid)
3myString.Substring(2)  // "t4711" (string)

Global functions return system values useful for workflow logic.

JSONPath Functions

Use the JSONPath functions in Evnet Rules and in the workflow actions to read values directly from JSON payloads. They use the same JSONPath evaluation as the JsonPath and JsonPathValue workflow actions.

1JsonPath(Data, "$.Price")             // returns the selected value as a string
2JsonPathValueString(Data, "$.Price")  // returns the selected value as a string
3JsonPathValueDecimal(Data, "$.Price") // returns the selected value as a decimal

For example, use JsonPathValueString(Data, "$.Price") to access the Price value from a dictionary received in the event payload. Selecting a type-specific function lets you avoid separate JsonPathValue and Cast actions, reducing workflow complexity.

Function	Return type
JsonPath(string json, string jsonPath)	string
JsonPathValueInt(string json, string jsonPath)	int (Int32)
JsonPathValueBool(string json, string jsonPath)	bool
JsonPathValueDate(string json, string jsonPath)	DateTimeOffset
JsonPathValueDecimal(string json, string jsonPath)	decimal
JsonPathValueDouble(string json, string jsonPath)	double
JsonPathValueGuid(string json, string jsonPath)	Guid
JsonPathValueList(string json, string jsonPath)	List<object>
JsonPathValueLong(string json, string jsonPath)	long (Int64)
JsonPathValueObject(string json, string jsonPath)	Dictionary<string, object>
JsonPathValueObjectList(string json, string jsonPath)	List<Dictionary<string, object>>
JsonPathValueString(string json, string jsonPath)	string

13. Literals

135       // 35 (int)
2"35"     // "35" (string)
30xA      // 10 (byte)
40.5      // 0.5 (decimal)
5.5       // 0.5 (decimal)
6true     // true (bool)
7false    // false (bool)
8null     // null (object)

Evaluation Order

Expressions are resolved using operator precedence. Brackets can override the default order:

• Multiplication > Addition
• Logical AND > Logical OR
• Unary operators > Binary operators

Examples:

Variable	Type	Content
a	bool	true
b	bool	false
c	bool	false
myInt	int	15

• Multiplication > Addition

1myInt * 2 + myInt       // 45 (int)
2myInt * (2 + myInt)     // 255 (int)

• Logical AND > Logical OR

1a OR b AND c            // true (bool)
2(a OR b) AND c          // false (bool)

• Unary operators > Binary operators

1-myInt + 16 < 0         // false (bool)
2-(myInt + 16) < 0       // true (bool)
3NOT a AND b             // false (bool)
4NOT (a AND b)           // true (bool)

Brackets should be used liberally for clarity, especially in complex logical conditions.

Best Practices

• Always ensure expressions return the expected type (e.g., boolean for conditions, string for concatenations).
• Use brackets to make evaluation explicit, especially for complex logical conditions.
• Prefer expressions for simple transformations; use CustomScript actions when multiple statements or loops are required.
• Debug using Workflow Context and Logs to verify evaluated values at runtime.

Related Articles

• Custom Script Action - Authoring with the R-COM Gateway Script Language
• Set up Event Based Workflow
• MQTT Client Configuration in R-COM Gateway
• Workflow Actions