UiPath-ADPv1 Advanced Data Manipulation Practice Test 2 — 15 Questions

Question 1

A developer is building a reusable workflow that writes a DataTable to an Excel file using the Write Range activity. The DataTable contains a DateTime column and an Integer column, but after writing, dates appear as serial numbers and integers appear as text. The developer wants to control the output formatting programmatically before writing. (Choose two.)

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

Build a new DataTable with String columns, copy formatted values into it, and pass that table to Write Range.. Controlling how values appear requires formatting them into strings before the write. Both building a new all-String DataTable and adding a formatted String column achieve that by presenting text to Write Range, which writes cells literally. Attempting to change an existing column's type or expecting per-column formatting properties fails.

Answer

Set the DataColumn.DataType to typeof(String) on the existing DateTime column so Excel stores the values as text.

Answer

Convert the DataTable to a String array using Output Data Table, then write the string with Write Text File into the .xlsx path.

Answer

Use the Format Cells feature inside the Write Range activity's properties, selecting the DateTime column and applying a custom format.

Question 2

A UiPath workflow maintains a DataTable of orders and must add a computed 'Total' column whose value is Quantity multiplied by UnitPrice for every row. The table has 80,000 rows and the workflow runs hourly. Which approach applies the calculation most efficiently while keeping the DataTable schema valid?

Accepted Answer

Add a DataColumn named 'Total' of type Double to the DataTable, then loop with For Each Row and assign row("Total") for each row.. Adding a typed DataColumn once and then assigning row values in a single For Each Row pass keeps the schema stable and computes each total with minimal overhead. Creating the column per iteration breaks the schema, LINQ projections add materialization cost without reducing work, and RowFilter only selects rows. The direct loop is both correct and the most efficient fit for an 80,000-row hourly job.

Answer

Convert the DataTable to a List(Of DataRow) with AsEnumerable, compute totals with a LINQ Select, and assign the results back by index.

Answer

Use the Add Data Column activity inside the For Each Row loop so the column is created just before each row is processed.

Answer

Set the DataTable's DefaultView.RowFilter to 'Quantity * UnitPrice' so the computed column is generated automatically when the view is read.

Question 3

You are processing a large DataTable named 'dt_Inventory' and need to filter it to include only rows where the 'Status' column is 'Active' and 'Stock' is greater than 50. Which method is most efficient for a performance-optimized workflow?

Accepted Answer

Apply the .AsEnumerable().Where(Function(r) r("Status").ToString = "Active" AndAlso CInt(r("Stock")) > 50).CopyToDataTable() method.. Using LINQ with the .Where() method is the standard for high-performance filtering in UiPath. It executes in memory, avoiding the overhead of iterating through rows using a For Each loop. This approach is critical when dealing with datasets containing thousands of records, as it reduces automation execution time and memory consumption significantly, ensuring the process remains responsive under load.

Answer

Use a For Each Row activity and an If condition to add items to a new DataTable.

Answer

Use the Filter Data Table activity with the 'Remove' mode to delete unwanted rows.

Answer

Use a Select method with a SQL query syntax string directly on the DataTable object.

Question 4

You have a JSON string containing nested objects and arrays. Which TWO approaches are best for parsing this data into a usable format within UiPath?

Accepted Answer

Use the 'Deserialize JSON' activity and cast the output to a JObject.. Parsing JSON requires robust handling of hierarchies. Using the 'Deserialize JSON' activity is the primary UiPath-native approach, providing access to JObject or JArray types. Alternatively, using 'Deserialize JSON Array' is essential when the root element is a collection. These methods allow developers to use LINQ or index-based access to extract specific fields efficiently, which is vital for integration with complex REST API responses.

Answer

Use a 'For Each' loop with String.Split to manually parse the JSON structure.

Answer

Use the 'Regex Match' activity to extract every field via named capture groups.

Answer

Convert the JSON to a DataTable using an Invoke Code activity.

Question 5

Which of the following is the most appropriate way to handle null values when performing a calculation on a DataRow column?

Accepted Answer

Use row.IsNull("Column") to check for null values.. Using the IsDBNull method is the safest way to check for null values in DataTables. DataRows often contain DBNull.Value instead of standard nulls, which causes errors if accessed directly in calculations. Always explicitly checking for DBNull ensures that your automation handles missing data gracefully, preventing runtime exceptions that would otherwise stop the process. This practice is vital for building resilient automations that can handle inconsistent or incomplete input data sources effectively.

Answer

Use row("Column").ToString = "" to check for nulls.

Answer

Use If row("Column") Is Nothing to check for nulls.

Answer

Use a Try-Catch block to handle exceptions when calculating.

Question 6

Which of the following is the most efficient way to merge two DataTables that have the same schema?

Accepted Answer

Use the 'Merge Data Table' activity.. The DataTable.Merge method is specifically optimized for this scenario. It handles data integration natively, including constraints and primary key handling. Using Merge is far more efficient than iterating through rows and manually importing them. It reduces code complexity and minimizes potential errors, making it the standard best practice for synchronizing data between multiple sources in an automation workflow.

Answer

Use a For Each Row loop to copy values one by one.

Answer

Use a LINQ query to join the tables and create a new one.

Answer

Write both tables to a CSV and use an 'Append' command.

Question 7

Which THREE of the following are valid ways to handle dynamic JSON keys when using the 'Deserialize JSON' activity?

Accepted Answer

Access properties using indexers: jObject("DynamicKey").ToString().. When JSON keys are dynamic, static dot-notation fails. You must access fields using indexed notation (e.g., jsonObject('key')), use LINQ to filter the properties, or iterate through the JObject.Properties() collection. These methods allow you to access keys that are not known until runtime. Mastering these techniques is essential for building robust automations that can integrate with evolving APIs where key names might change or be generated dynamically.

Answer

Cast the JSON object to a fixed class type.

Answer

Use the 'Invoke Code' activity to call a Java-based parser.

Question 8

You are performing a string manipulation to extract a sub-string. Which method is most performant when the string length is consistently large?

Accepted Answer

Use the Substring method with calculated start and length indices.. The Substring() method is highly optimized in .NET and is preferred for extracting parts of a string. When combined with IndexOf() or LastIndexOf() to locate delimiters, it allows for fast, memory-efficient extraction. This approach avoids the overhead of complex Regex processing. In professional automation, choosing the most efficient method for the task is crucial to maintaining low latency and high execution speeds in high-volume data extraction scenarios.

Answer

Use the Regex.Match activity.

Answer

Use a series of Split and array index operations.

Answer

Use the 'Replace' method to remove unwanted parts.

Question 9

When updating a DataTable row, what is the impact of using the .BeginEdit() and .EndEdit() methods?

Accepted Answer

They defer constraint checking and event firing until the update is complete.. Using .BeginEdit() and .EndEdit() suspends event firing and constraint checking during the row update process. This significantly improves performance when performing multiple column updates in a single row. By preventing the DataTable from validating the row after every individual field change, you minimize unnecessary processing overhead. This is a critical best practice for optimizing data manipulation in high-volume, performance-sensitive workflows where large rows are updated frequently.

Answer

They enable asynchronous updates for better concurrency.

Answer

They prevent the DataRow from being modified by other threads.

Answer

They automatically save the changes to the underlying database.

Question 10

You are processing a large JSON string containing employee records. Which LINQ expression correctly extracts a list of names for all employees whose 'department' is 'Finance'?

Accepted Answer

JArray.Parse(jsonString).Where(Function(x) x("department").ToString = "Finance").Select(Function(x) x("name").ToString).ToList(). Selecting data from JSON strings efficiently requires parsing the string into a JObject or JArray using Newtonsoft.Json. The LINQ 'Where' clause filters the collection based on the property value, while the 'Select' method projects only the required field. Mastering these transformations is crucial for handling complex API responses, reducing code complexity compared to traditional For Each loops, and ensuring high-performance data processing within large-scale UiPath automation projects.

Answer

JArray.Parse(jsonString).Select(Function(x) x("name")).Where(Function(x) x("department").ToString = "Finance")

Answer

JArray.Parse(jsonString).Filter(Function(x) x("department") = "Finance").Map(Function(x) x("name"))

Answer

JObject.Parse(jsonString).Select(Function(x) x("name").Where(Function(y) y("department") = "Finance"))

Question 11

Which TWO methods are most efficient for performing bulk updates on a DataTable containing over 50,000 rows without impacting workflow performance significantly?

Accepted Answer

Use the AsEnumerable method with LINQ to update values in memory.. Efficient data manipulation requires avoiding row-by-row iteration in large datasets. Using 'AsEnumerable' allows for LINQ-based operations which are optimized for memory usage. Alternatively, using an Invoke Code activity to execute C# or VB.NET logic directly on the underlying DataTable memory space bypasses the overhead of UiPath activity execution, significantly reducing processing time for high-volume data operations essential in enterprise-grade RPA solutions.

Answer

Use a For Each Row in Data Table activity with an Update Row Item activity inside.

Answer

Use the Filter Data Table activity to split the table into chunks and process individually.

Answer

Use the Append Range activity to write the updated rows back to the Excel file.

Question 12

Which THREE actions are best practices when using Dictionary<TKey, TValue> for large-scale data storage within a workflow?

Accepted Answer

Always initialize the dictionary using the 'New Dictionary(Of K, V)' syntax.. Dictionaries offer O(1) lookup time, making them superior to DataTables for key-based data retrieval. However, they are not thread-safe by default, so proper initialization and access patterns are critical. Using dictionaries effectively improves workflow performance and code readability, allowing developers to manage lookups efficiently without needing to re-scan large lists or tables repeatedly during runtime execution.

Answer

Use global variables for all dictionaries to ensure state persistence.

Answer

Use the 'Add' method to update existing key values within the loop.

Question 13

Which string method effectively removes leading and trailing whitespace from a variable?

Accepted Answer

myString.Trim(). Data cleaning is a standard task in RPA, where input data from OCR or web scraping often contains unwanted padding characters. The Trim() method is specifically designed for this purpose. Mastery of string manipulation is foundational for ensuring the accuracy of data comparisons, database updates, and inputting clean values into target applications, preventing common logic errors during automation execution.

Answer

myString.Clean()

Answer

myString.Strip()

Answer

myString.RemoveWhitespace()

Question 14

Which TWO methods are valid ways to add a new column to an existing DataTable?

Accepted Answer

dt.Columns.Add("NewColumnName", GetType(String)). Adding columns to a DataTable at runtime is a common requirement when enriching data during processing. Both the 'Add' method of the Columns collection and the use of 'Invoke Code' are valid ways to achieve this. Knowing these methods allows developers to dynamically expand data structures without needing to define complex schemas in the project design phase, increasing automation flexibility.

Answer

dt.Rows.Add("NewColumnName")

Answer

dt.Columns.Insert("NewColumn")

Answer

dt.AddColumn("NewColumn")

Question 15

Which sequence of operations is correct?

Accepted Answer

myList.Remove("Banana"); myList.Add("Date"). List manipulation requires understanding the specific methods available for modifying collections. 'Remove' identifies the object to delete, while 'Add' appends to the end. Choosing the correct collection type (List vs. Array) is vital for efficient data handling. Lists provide the necessary dynamic resizing capability, making them the preferred choice for scenarios where the number of items changes during the automation execution flow.

Answer

myList.Delete("Banana"); myList.Append("Date")

Answer

myList.RemoveAt("Banana"); myList.Add("Date")

Answer

myList.Pop("Banana"); myList.Push("Date")