6.4 Invoke Method & Invoke Code Activities

6.4 Invoke Method & Invoke Code Activities

Core Concept: When no activity does what you need, UiPath gives you two ways to run .NET code directly. Invoke Method calls one existing method on a type or an object. Invoke Code runs a small block of VB.NET or C# that you write inside the activity. The exam description lists both under Advanced Data Manipulation, so know how to configure each, how arguments flow in and out, and when a library or coded workflow is the better home for the logic.

1. The Invoke Method Activity: Static vs. Instance Invocations

When an automation requires executing a .NET method that is not exposed as a standard visual activity, developers use the Invoke Method activity. It executes any accessible method on a .NET class or object using reflection without requiring external custom code compilation.

Configuring Static Methods

To call a static method (a method belonging to the class itself, not an instantiated object):

1. TargetType: Set to the fully qualified type (e.g., System.IO.File, System.Math, System.Convert).
2. TargetObject: Leave blank (set to Nothing).
3. MethodName: Enter the exact method name as a string (e.g., "Copy", "Round").
4. Parameters: Configure the method's input parameters in the Parameters collection modal.
5. Result: Map to a workflow variable if the static method returns a value.

Enterprise Example: System.IO.File.Copy

• TargetType: System.IO.File
• MethodName: "Copy"
• Parameters:
  • Parameter 1: Direction In, Type String, Value in_SourcePath
  • Parameter 2: Direction In, Type String, Value in_DestinationPath
  • Parameter 3: Direction In, Type Boolean, Value True (overwrite)

Configuring Instance Methods

To call an instance method (a method operating on a specific instantiated object):

1. TargetType: Leave blank (or default null).
2. TargetObject: Provide the instantiated variable name (e.g., myList, myDataTable, myStringBuilder).
3. MethodName: Enter the method name (e.g., "Sort", "Reverse", "Clear", "Append").
4. Parameters: Supply arguments required by the instance method signature.
5. Result: Map to a variable if the method yields a return value.

Enterprise Example: Sorting a Generic List in Place

• TargetObject: workItemsList (where workItemsList is List(Of String))
• MethodName: "Sort"
• Parameters: Empty (calls default parameterless sort)

Parameter Direction Types

• In: Passes an argument value into the method by value.
• Out: Captures a value produced by the method via a .NET out parameter.
• InOut: Passes a reference into the method and captures the mutated value (ref in C# / ByRef in VB.NET).

---

2. The Invoke Code Activity: Native Scripting & Architectural Tradeoffs

The Invoke Code activity allows developers to author raw Visual Basic .NET or C# code blocks directly inside a UiPath workflow. It executes synchronously within the workflow runtime process.

Configuring Arguments in Invoke Code

Unlike workflow scopes where activities share global workflow variables, Invoke Code operates in an isolated code scope. Variables must be explicitly mapped through the Arguments collection:

• Direction: In (read-only input), Out (output created inside code), InOut (mutated reference).
• Type: Must strictly match the .NET data type expected by the script.
• Name: The identifier used inside the code snippet.

' VB.NET Code Snippet inside Invoke Code activity
' Arguments:
'   in_RawDataTable (In, DataTable)
'   in_Multiplier (In, Double)
'   out_SummaryDict (Out, Dictionary(Of String, Double))

out_SummaryDict = New Dictionary(Of String, Double)()

For Each row As DataRow In in_RawDataTable.Rows
    Dim category As String = row("Category").ToString()
    Dim amount As Double = Convert.ToDouble(row("Amount")) * in_Multiplier
    
    If out_SummaryDict.ContainsKey(category) Then
        out_SummaryDict(category) += amount
    Else
        out_SummaryDict.Add(category, amount)
    End If
Next

Exception Handling inside Invoke Code

• Unhandled exceptions inside an Invoke Code block immediately bubble up to the parent workflow as a System.Exception, halting workflow execution unless caught by an enclosing Try Catch activity.
• Developers can embed internal Try...Catch blocks within the Invoke Code script to handle recoverable edge cases, log errors, or populate diagnostic Out arguments.

Architectural Decision Framework: When to Use What

---

Invoke Code Details Worth Knowing

• Language. Each Invoke Code activity has a Language property (VB.NET or C#). It does not have to match the project's expression language.
• Namespaces. The code can use the namespaces imported in the project's Imports panel, plus fully qualified names.
• No class definitions. The body is the inside of a method, so you cannot declare classes there. Put reusable types in a code source file (.cs) in the project or in a referenced library.
• Arguments are the only link to the workflow. Workflow variables are not visible inside the code unless you pass them in the Arguments collection, with a direction of In, Out, or In/Out.
• Debugging. You cannot step through individual lines of an Invoke Code body with Studio breakpoints; the activity runs as a single step. Log values with Console.WriteLine, which writes to the Output panel, or move complex logic into a coded workflow where the IDE supports breakpoints.

Choosing the Right Tool