Using low-code workflow in coded automation

This part of the tutorial shows you how to invoke a low-code workflow inside a coded automation. The scenario involves:

Creating a coded workflow (CS file), named Random, that generates a random value within a specific range determined by minimum and maximum integer values you provide.
Creating a low-code XAML workflow, named Increment, that adds one to any given result, thus incrementing the received value.
Creating another coded workflow (a CS file), named IncrementProxy, that takes the randomly generated value from the Random workflow, invokes the Increment XAML workflow on this value (using the workflows object), and then returns the incremented result to the calling environment.

1. Create the `Random` coded workflow

From the File group, create a new coded workflow.
Change the Execute() public class to accept two int type input parameters named min and max, and return an int. The input parameters represent the boundaries within which a random value is generated, while the return parameter symbolizes the generated random value itself.
For example, change public void Execute() to public int Execute(int min, int max).
Create a new object of the Random class, using the new keyword and Random() constructor.
1. Use the Next() method from the Random class instance to generate a random number within the range between min and max.
2. Assign this generated random number to a new variable, named randomValue.
Return the randomValue variable. Returning this variable back to the Execute method allows you to access the randomValue variable in any coded workflow inside your project that runs using the Execute method.

public class Random : CodedWorkflow
    {
        [Workflow]
        public int Execute(int min, int max)
        {
            // Get a random value between min and max
            var randomValue = new Random().Next(min, max);
            
            // Return it to the caller
            return randomValue;
        }
    }public class Random : CodedWorkflow
    {
        [Workflow]
        public int Execute(int min, int max)
        {
            // Get a random value between min and max
            var randomValue = new Random().Next(min, max);
            
            // Return it to the caller
            return randomValue;
        }
    }

2. Create the `Increment` low-code workflow

From the File group, create a new Workflow.
Create two arguments of type Int32, named result and input.. Set the direction of the result argument as Out, and the direction of the input argument as In.
Add an Assign activity.
1. In the Save to field, input the result variable.
2. In the Value to save field, add the following expression, that increments the input value: input + 1.

Create the `IncrementProxy` coded workflow

From the File group, create a new coded workflow.
Change the Execute class to take the random variable created at the Create the Random coded workflow step in this tutorial, and change the class to return an int argument.
Invoke the Increment low-code workflow using the workflows object, pass the random Int32 variable to it, and store the output to a variable named out_arg.
Log the out_arg variable in the output panel.
Return the out_arg variable back to the Execute method.

public class Workflow : CodedWorkflow
    {
        [Workflow]
        public int Execute(int random)
        {
            // Receive random from the XAML and increment it 
            var out_arg  = workflows.Increment(random);   
            
            // Log the result and return it to the caller
            Log(out_arg.ToString());
            
            // Return the result to the caller
            return out_arg;
        }
    }public class Workflow : CodedWorkflow
    {
        [Workflow]
        public int Execute(int random)
        {
            // Receive random from the XAML and increment it 
            var out_arg  = workflows.Increment(random);   
            
            // Log the result and return it to the caller
            Log(out_arg.ToString());
            
            // Return the result to the caller
            return out_arg;
        }
    }