ExamFinch.com My Study

Study guide

2.4 Adapting REFramework: Tabular Data, Collections & Linear Processes

Practice this exam

UiPath Automation Developer Professional UiPath-ADPv1

Track your progress as you read

Finished sections get a check mark.

1 Chapter 1: Exam Overview & Blueprint Map

1.1 About the UiPath-ADPv1 Exam: Format, Fees & Policies 1.2 The Exam Topics Mapped to This Guide & a Study Plan

2 Chapter 2: REFramework Architecture & State Dynamics

2.1 State Machine Architecture & The Four Core States 2.2 Configuration Management: Settings, Constants, and Assets 2.3 Transaction Types & The Dispatcher vs. Performer Architecture 2.4 Adapting REFramework: Tabular Data, Collections & Linear Processes

3 Chapter 3: REFramework Exception Handling & Recovery

3.1 BusinessRuleException vs. System.Exception Handling Patterns 3.2 Retry Mechanisms: Queue Retries vs. REFramework MaxRetryNumber 3.3 Consecutive System Exceptions & Graceful Process Termination

4 Chapter 4: State Machines, Custom Log Fields & REFramework Testing

4.1 Building State Machine Projects in Studio 4.2 Logging Levels, Robot Logs & Custom Log Fields in REFramework 4.3 Testing a REFramework Project With and Without Orchestrator Queues

5 Chapter 5: LINQ Queries & DataTable Operations

5.1 LINQ Essentials for Collections & Filtering 5.2 Advanced DataTable Querying with LINQ 5.3 In-Memory DataTable Transformations & Column Operations

6 Chapter 6: Regex, DateTime, JSON & Invoke Activities

6.1 Regular Expressions & Text Parsing for Automation 6.2 DateTime Formatting, Timezone Conversions & TimeSpan Calculations 6.3 JSON Parsing, JSONPath & Serialization with Newtonsoft.Json 6.4 Invoke Method & Invoke Code Activities 6.5 Data Referencing in Invokes: DataTable, List & Dictionary Arguments

7 Chapter 7: Modern UI Automation & Unified Targeting

7.1 Modern Design Experience & The Unified Target Concept 7.2 Anchors, Relative Elements & UI Automation Activities 7.3 Dynamic Selectors, Variables & Wildcards in Selectors

8 Chapter 8: Object Repository, Computer Vision & Remote Runtime

8.1 Object Repository & UI Descriptor Libraries 8.2 AI Computer Vision for Unattended & Remote Interfaces 8.3 Automation in Virtual Environments & UiPath Remote Runtime

9 Chapter 9: Advanced UI Automation: Browser Modes, Agentic UI & macOS

9.1 Browser Automation with the WebDriver Protocol 9.2 Agentic UI Automation: ScreenPlay, Semantic Activities & Healing Agent 9.3 macOS Automation: Native Apps, Office Apps & AppleScript

10 Chapter 10: Advanced Control Flow & Exception Architecture

10.1 Flowcharts, Sequences & Parallel Control Flow Patterns 10.2 Global Exception Handler Architecture & ErrorAction Directives 10.3 TryCatch, Retry Scope & Custom Exception Architectures

11 Chapter 11: Orchestrator Queues & Transaction Management

11.1 Queue Architecture, SpecificContent & Transaction Lifecycles 11.2 Queue Items SLA, Postpone, Deadlines & Priority Scheduling 11.3 Bulk Operations, Transaction Status Updates & Queue Triggers

12 Chapter 12: Orchestrator Tenant & Folder Entities

12.1 Asset Types, Per-Robot Assets & External Credential Stores 12.2 Modern Folder Hierarchy, User/Robot Assignment & Permissions 12.3 Storage Buckets, Webhooks & Environment Promotion 12.4 Orchestrator Tags: Labels, Properties & Governance

13 Chapter 13: Unattended Execution, API Triggers & Cloud Robots

13.1 Unattended Job Execution: Folders, Priorities, Background vs. Foreground & Runtimes 13.2 API Triggers: Starting Jobs from External Systems over HTTP 13.3 Serverless and Cloud VM Robots: Cloud-Hosted Execution Options

14 Chapter 14: Monitoring, Recording & Solutions Management

14.1 Orchestrator Monitoring, Trigger Alerts & Job Health 14.2 Job and Transaction Recording: Troubleshooting Faulted Unattended Jobs 14.3 Solutions Management: Packaging and Deploying Automations with Their Resources

15 Chapter 15: Debugging, Remote Debugging & Profiling

15.1 Studio Debugging Tools: Breakpoints, Panels & Execution Control 15.2 Remote Debugging: Remote Machine and Unattended Robot Connections 15.3 Profile Execution: Finding Performance Bottlenecks in Studio

16 Chapter 16: RPA Testing & Test Suite

16.1 UiPath Test Suite Overview, Test Cases & Given-When-Then Structure 16.2 Data-Driven Testing, Test Verification Activities & Mock Activities 16.3 CI/CD Pipelines with uipcli & Test Manager Traceability

17 Chapter 17: Long-Running Workflows, Action Center & Apps

17.1 Long-Running Workflows: Persistence, Suspend and Resume 17.2 Action Center & Human-in-the-Loop Orchestration 17.3 UiPath Apps: Action Apps, Automations & Integration Service

18 Chapter 18: Trigger-Based Attended Automation & Callouts

18.1 Trigger-Based Attended Automation: Forms, Triggers & Global Variables 18.2 Running Local Triggers & the Event Inspection Tool 18.3 Callouts & Forms for Attended Guidance

19 Chapter 19: UiPath Assistant & Robot Sessions

19.1 UiPath Assistant: Automations, Reminders, Widgets & Configuration 19.2 Robot Session (Picture in Picture): Child Session vs. Virtual Desktop

20 Chapter 20: Autopilot for Developers & Autopilot for Everyone

20.1 Autopilot for Developers: AI Assistance in Studio and Studio Web 20.2 Autopilot for Everyone: Chat, Automations & Clipboard AI

21 Chapter 21: API Automation & Integration Service

21.1 Integration Service: Connectors, Connections & Connector Activities 21.2 API Workflows in Studio Web 21.3 HTTP Requests: Web APIs, the Orchestrator API & Connector Requests 21.4 Connector Builder: Custom Integration Service Connectors 21.5 Integration Service Event Triggers: Connected and Disconnected 21.6 GenAI Activities: Generative AI Inside Workflows

22 Chapter 22: Data Service, Context Grounding & Coded Workflows

22.1 Data Fabric (Data Service) Entities: Modeling Business Data 22.2 Data Fabric Activities and the Platform Connector 22.3 Context Grounding: Retrieval-Augmented Generation with Company Data 22.4 Coded Automations: Structure, Arguments & Invoking Workflows 22.5 Coded Automation Services: Orchestrator, UI Automation, Microsoft 365 & Custom Services

23 Chapter 23: Integrated Scenario Practice

23.1 Integrated Scenario Practice: Designing an End-to-End Solution

2.4 Adapting REFramework: Tabular Data, Collections & Linear Processes

Key Takeaways Explain This Topic AI

Changing the transaction source means updating the TransactionItem type in Main.xaml and in the GetTransactionData, Process, and SetTransactionStatus arguments.

For tabular data, load the DataTable once into an In/Out argument and return Rows(in_TransactionNumber - 1) , because TransactionNumber starts at 1 while rows are zero-based.

Returning Nothing from GetTransactionData.xaml is what ends the run through the No Data transition.

SetTransactionStatus.xaml calls Set Transaction Status only for QueueItem transactions, so non-queue projects need their own status record.

A linear process returns one item on the first cycle and Nothing on the second, and uses MaxRetryNumber for retries.

Last updated: September 2026

2.4 Adapting REFramework: Tabular Data, Collections & Linear Processes

Core Concept: The REFramework template assumes an Orchestrator queue, but the exam description expects you to adapt it in three other ways: a transactional project with tabular data (DataTable rows), a transactional project with a collection (a list of files, emails, or IDs), and a linear process that runs its business logic once. Every adaptation touches the same three places: the TransactionItem type, GetTransactionData.xaml , and the way the result is recorded.

Step 1: Change the TransactionItem Type Everywhere

TransactionItem is a variable in Main.xaml and an argument in several framework workflows. When you change its type, update all of them, or the project will not compile:

  • Location Name Change it to (tabular example)
  • Main.xaml variables TransactionItem System.Data.DataRow
  • GetTransactionData.xaml out_TransactionItem System.Data.DataRow
  • Process.xaml in_TransactionItem System.Data.DataRow
  • SetTransactionStatus.xaml in_TransactionItem System.Data.DataRow

For tabular data, also add a variable in Main.xaml , such as TransactionData of type DataTable , and pass it to GetTransactionData.xaml as an In/Out argument ( io_TransactionData ). The table is loaded once and then kept for every later cycle.

  • Step 2: Rewrite GetTransactionData.xaml
  • Tabular data (DataTable rows) ' GetTransactionData.xaml (tabular)
  • If in_TransactionNumber = 1 Then
  • ' Read Range / Run Query once, store the result in io_TransactionData
  • End If
  • If in_TransactionNumber <= io_TransactionData.Rows.Count Then
  • out_TransactionItem = io_TransactionData.Rows(in_TransactionNumber - 1)
  • Else
  • out_TransactionItem = Nothing ' no more rows: go to End Process
  • End If

Two details trip people up:

TransactionNumber starts at 1 , but Rows is zero-based , so the index is in_TransactionNumber - 1 .

Returning Nothing is what triggers the No Data transition to End Process. Forgetting the Else branch causes an IndexOutOfRangeException after the last row.

Loading the data only on the first cycle (or only when the table is Nothing ) matters. Re-reading the Excel file on every cycle is slow and can pick up rows that changed during the run.

Collections (files, emails, IDs)

A collection works the same way with a different type. For a folder of PDFs, make TransactionItem a String (or FileInfo ) and keep a String() array of paths: If in_TransactionNumber = 1 Then io_FilePaths = Directory.GetFiles(in_Config("InputFolder").ToString, "*.pdf")

out_TransactionItem = If(in_TransactionNumber <= io_FilePaths.Length, io_FilePaths(in_TransactionNumber - 1), Nothing)

For mailboxes, a List(Of MailMessage) or an Integration Service email object plays the same role.

Linear process (run once)

A linear process, such as a nightly report download, has no records to loop over. Give it one "transaction" and then stop: If in_TransactionNumber = 1 Then

  • out_TransactionItem = "RunOnce"
  • Else
  • out_TransactionItem = Nothing
  • End If

You keep the framework's benefits: configuration loading, clean initialization, the business versus system exception split, screenshots, and robot retries through MaxRetryNumber .

Step 3: Record the Outcome Without a Queue

SetTransactionStatus.xaml only calls the Set Transaction Status activity when the item is a QueueItem . The template checks with in_TransactionItem.GetType Is GetType(UiPath.Core.QueueItem) before calling it. For DataRows, files, or linear runs, that activity is skipped automatically, and the framework still does the following:

  • logs the outcome with the transaction log fields (status, number, ID, and the two extra fields),
  • increments io_TransactionNumber , or the retry counter for robot retries,

takes a screenshot and closes the applications after a System Exception.

Because there is no queue to show status, you need your own record: write a Status column back to the DataTable and save it at End Process, move processed files to Done or Error folders, or send a summary email. Set out_TransactionID , out_TransactionField1 , and out_TransactionField2 in GetTransactionData.xaml (for example, the invoice number) so every log line identifies the record.

Retries Without a Queue

Without Orchestrator's queue retry, MaxRetryNumber on the Constants sheet is the retry mechanism. Set it above 0 (for example, 2). A System Exception then keeps the same TransactionNumber , returns through Initialization, and fetches the same row or file again. A business exception never retries and moves on to the next record.

Scenario TransactionItem type Data loaded End condition Retry setting

Queue performer (default) QueueItem Get Transaction Item on every cycle Queue empty or stop requested Queue Auto Retry; MaxRetryNumber = 0

  • Excel or SQL rows DataRow Once, into io_TransactionData TransactionNumber > row count MaxRetryNumber > 0
  • Folder of files String or FileInfo Once, into an array Index past the array length MaxRetryNumber > 0
  • Linear run String or Boolean Not needed Second cycle returns Nothing MaxRetryNumber > 0 if a retry makes sense

Tip

A tabular performer cannot be scaled across several robots, because each robot would read the same file and process the same rows. When volume or parallelism matters, convert the source into a queue with a Dispatcher.