# 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:

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

1. 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.
2. Creating a low-code XAML workflow, named `Increment`, that adds one to any given result, thus incrementing the received value.
3. 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

1. From the **File** group, create a new coded workflow.
2. 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)`.
3. 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`.
4. 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;
        }
    }
```

## 2. Create the `Increment` low-code workflow

1. From the **File** group, create a new **Workflow**.
2. 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**.
3. 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`.

   ![docs image](https://dev-assets.cms.uipath.com/assets/images/studio/2024-10-docs-image-344489-27d49b20.webp)

## Create the `IncrementProxy` coded workflow

1. From the **File** group, create a new coded workflow.
2. 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.
3. 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`.
4. Log the `out_arg` variable in the output panel.
5. 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;
        }
    }
```