Studio User Guide

Last updated Sep 10, 2025

Invoking Code Source File

Use this workflow to invoke a coded source file within a low-code workflow. In this example, we create a class called TimeSpanHelper in the TimeSpanHelper.cs coded source file. This class generates a random time span based on the specified bounds. To integrate this class in a low-code workflow, we use an Invoke Workflow File activity, followed by other low-code activities, depending on the use case.

Create a coded source file. For this example, name it TimeSpanHelper.cs.
In the coded source file, create a public class named TimeSpanHelper.
1. Inside the TimeSpanHelper class, declare a private static Random object named _random to generate random values.
```
private static Random _random = new Random();private static Random _random = new Random();
```
2. Declare a private static object named _lockObj to secure the thread, while working with multiple threads at the same time..
```
private static object _lockObj = new object();private static object _lockObj = new object();
```
3. Implement a public static method called GetRandomTimeSpanBetween that takes two integer parameters: lowerBoundMs and upperBoundMs.
```
public static TimeSpan GetRandomTimeSpanBetween(int lowerBoundMs, int upperBoundMs)
    {public static TimeSpan GetRandomTimeSpanBetween(int lowerBoundMs, int upperBoundMs)
    {
```
4. Use the lock statement with _lockObj to secure this thread, while working with multiple threads at the same time.
```
lock (_lockObj)
      {lock (_lockObj)
      {
```
5. Within the lock block, generate a random integer value using _random.Next and pass lowerBoundMs and upperBoundMs as the arguments.
```
var ms = _random.Next(lowerBoundMs, upperBoundMs);var ms = _random.Next(lowerBoundMs, upperBoundMs);
```
6. Convert the generated random value to a TimeSpan object using TimeSpan.FromMilliseconds and return this value directly from the method with the following command return:
```
return TimeSpan.FromMilliseconds(ms);return TimeSpan.FromMilliseconds(ms);
```
Based on these steps, your final code should look like this:
```
public class TimeSpanHelper
  {
    private static Random _random = new Random();
    private static object _lockObj = new object();

    public static TimeSpan GetRandomTimeSpanBetween(int lowerBoundMs, int upperBoundMs)
    {
      lock (_lockObj)
      {
        var ms = _random.Next(lowerBoundMs, upperBoundMs);
        return TimeSpan.FromMilliseconds(ms);
      }
    }
  }  public class TimeSpanHelper
  {
    private static Random _random = new Random();
    private static object _lockObj = new object();

    public static TimeSpan GetRandomTimeSpanBetween(int lowerBoundMs, int upperBoundMs)
    {
      lock (_lockObj)
      {
        var ms = _random.Next(lowerBoundMs, upperBoundMs);
        return TimeSpan.FromMilliseconds(ms);
      }
    }
  }
```
Create a low-code workflow. For this example, name it WorkflowUsingCodeSourceFile.
Add a Log Message activity to output a random timespan between two and four seconds.
In the Message field, type the name of the project, call the coded source file, and then call the GetRandomTimeSpanBetween method.
In the example below, CodedWorkflowInteroperability is the name of the project.
```
CodedWorkflowInteroperability.TimeSpanHelper.GetRandomTimeSpanBetween(2000, 4000)CodedWorkflowInteroperability.TimeSpanHelper.GetRandomTimeSpanBetween(2000, 4000)
```

Was this page helpful?

PREVIOUSUsing the RunWorkflow method

NEXTUsing Coded automation in Low-Code workflow

Support and Services

Get The Help You Need

UiPath Academy

Learning RPA - Automation Courses

UiPath Forum

UiPath Community Forum

Trust and Security

Cookies Policy