New release 2.0.6 is more about workflow engine features.

Recently we have released version 2.0.6 of both framework runtime and designer. There is something special about this particular version which is it emphasizes in workflow functionality in FlexRule.

In this version at runtime we introduce the new abstract node named GroupNode.


This GroupNode enables you to define more complex workflow behavior in your model:

1. Exception handling using TryNode
2. Controlled looping mechanism using LoopNode
3. Processing some nodes under a transactional scope using TransactionNode
4. Logically grouping  a set of nodes using ScopeNode

There are two other new nodes also that are not a GroupNode but still they are part of the workflow definition node hierarchy:
1. ThrowNode  would allow you to throw an exception in workflow model (this node is not a GroupNode)
2. And a null activity is an activity can be used to synchronize multiple transition into one single outgoing transitions

New Designer features:

In designer also we support all of the mentioned nodes, simply use the new toolbox and drag the node you want. These new nodes are container node which means you can drag other nodes into them and they will be part of the group nodes.

In group container node there are two important properties:

1.       Initializer

2.       Finalizer

These two are the reference to two nodes placed inside the flow.

When a group node gets activated, in the workflow engine needs to decide which node of the container gets activated first. That would be the initialize node of the GroupNode.

Similar logic applies when the workflow engine requires to leave a GroupNode. When the execution reaches the Finalizer node in the GroupNode (displayed as a container in designer) it leaves the GroupNode and activates one of its outgoings node.

So similar to StartNode and EndNode, initializer node can not have any incoming transitions and finalizer node will not have any outgoing transitions.


Exception handling:

This node allows multiple outgoing transitions that accept exception type (if required) and when exception of a particular type happens that related outgoing transition will be activated.



Loop node:

A loop node is a GroupNode at runtime and a container node at designer that allows you to have multiple nodes inside. It iterates through the child nodes and executes them.



The important thing is LoopNode has entering and exiting condition needs to be set. If you don’t need an entering condition simply assign “true” to the condition.


Transaction node:

A transaction node is a container (GroupNode) that executes the child nodes under a transaction.



You may need to set a Mode and Timeout property of transaction (if required).


Scope node:

This node will be used to simply group the nodes. If a set of node needs to be grouped logically you can use this node.



GroupNode vs CompositeNode:

In the earlier version we have release a CompositeNode that may seem similar to GroupNode(s). Conceptually they may look similar but they have fundamental different design goals.

A composite node will be merged into the main flow during the load and will be considers as the main flow. In GroupNode they are already part of the main flow. Composite nodes can used to call another flow but GroupNodes are just a set of logically related workflow nodes that are grouped together and cannot have Start and End nodes.

Last updated September 22nd, 2020 at 11:36 am, Published October 16th, 2012 at 11:36 am