The first code sample is inefficient, and thread unsafe. getSmall() is called four times, getTiny() is called three times, and getTinyLength() is called twice. The second code sample is dangerous. Catching Exception when you just want to catch NullPointerException can lead to catching exceptions you didn't mean to catch. Plus, the overhead of constructing a NullPointerException object, throwing it, catching it, discarding it, and creating yet another NullPointerObject is non-trivial. Better would be:
Integer length = null;
if (big != null) {
Small small = big.getSmall();
if (small != null) {
Tiny tiny = small.getTiny();
if (tiny != null) {
length = tiny.getTinyLength();
}
}
}
if (length != null) {
return length;
} else {
// Throw exception, return null, or do whatever
}
Better still would be to hide that code away in an getter inside Big#getTinyLength(). A serious look at your data model should be in order. Can you have a Big that doesn't have a Small? Can you have a Small that doesn't contain a Tiny? Why would Tiny not have a length? If these members shouldn't ever be null, then let the JVM check for it and throw an exception, but then don't catch it, just to rethrow an equivalent one: return big.getSmall().getTiny().getTinyLength();
EDIT If you are
using Java 8, then the Optional type could simplify your code: public Integer getTinyLength (Big big) {
return Optional.ofNullable(big)
.map(Big::getSmall)
.map(Small:getTiny)
.map(Tiny::getTinyLength)
.orElse(null);
}
This constructs an Optional<Big> from big, and proceeds to unwrap it to get to the tiny length value. If big is null, or if any mapping function used in the
.map(...) calls returns null, an empty optional is produced. Finally, the value of the Optional<Integer> is returned if present, and null otherwise. System.Activities.Statements.TryCatch
Catches a specified exception type in a sequence or activity, and either displays an error notification or dismisses it and continues the execution. The activity has three main sections: - Try - holds the activity that could throw an exception;
- Catches - specifies the exception type and, optionally, holds an activity that informs the user about the found
exception;
- Finally - holds an activity that should be executed only if no error occurred or if the error was already caught.
There is no limit to how many Catches you can use in a Try Catch activity.
Keep in mind that this activity requires at least two of the three fields to be in use. You cannot run it only with the Try field completed. This is how the activity's container looks:
The activity body contains three fields: - Try - The activity performed which has a chance of throwing an error.
- Catches - The activity or set of activities to be performed when an error occurs.
- Exception - The exception type
to look for. Please note that you can add multiple exceptions.
- Finally - The activity or set of activities to be performed after the Try and Catches blocks are executed. This section is executed only when no exceptions are thrown or when an error occurs and is caught in the Catches section.
📘Notes: - If an activity is included in Try Catch, in the Try section, and the value of the ContinueOnError property is True, no error is caught when the project is executed.
- The Try Catch activity does not catch fatal exceptions such as:
- FatalException
- OutOfMemoryException
- ThreadAbortException
- FatalInternalException
- DisplayName - The display name of the activity.
- Private - If selected, the values of variables and arguments are no longer logged at Verbose level.
📘Note:
Pressing “Ctrl + T” places the selected activity inside the Try section of a Try Catch activity.
To better understand the importance of the Try Catch activity, we created an automation that gathers multiple names from a random name generator website and writes them in an Excel spreadsheet. You can download the initial workflow here. A Build Data Table activity is used to create a table in which to store the gathered names. Another workflow is invoked to read the web data. Finally, an Excel application scope activity is used to write the gathered information in the Excel file. First of all,
let’s run the automation to check for any errors. Notice that a Workflow Exception window is displayed. The Exception Type field tells us what the problem is. This is used in the Catches section of a Try Catch as the exception type to look for during the workflow execution.
As you can see in the screenshot above, when running the example workflow, there seems to be a problem with the Attach Browser container selector. The issue is that the selector fails to identify the browser window with the “Generate a Random Name - Fake Name
Generator” name. To catch this exception, we need to perform the following: - Drag the Try Catch activity from the Activities panel above the Invoke workflow activity.
- Place the Invoke workflow activity in the Try section of the Try Catch activity. This watches the Invoke workflow activity in case it throws an error.
- In the Catches section, select the
UiPath.Core.SelectorNotFoundException exception from the drop-down. If it’s not there, you can find it in the Browse and
Select a .Net Type window.
- Optionally, you can add a Message Box activity in the Catches section. You can fill in the Content field with an informative message between
quotes, in our case “Internet Explorer was closed. It will now open to continue the workflow execution”. This means that whenever the exception is caught, this message box is displayed, to inform the user that the browser is about to open so that the workflow is successfully executed.
- Drag the Element Exists activity in the Finally section. This is used to check if Internet Explorer is open on the page of interest,
https://www.fakenamegenerator.com.
- Open Internet Explorer and access the previously mentioned page.
- Use the Indicate on screen functionality to select the Internet Explorer window.
- Select the Element Exists activity and edit its selector so that it looks like this
<wnd app='iexplore.exe' title='Generate a Random Name - Fake Name Generator - Internet Explorer' />. This selector ensures that the Element Exists activity only looks for an
active Internet Explorer window in which the aforementioned page is open. - In the Output property, create a variable with a relevant name, such as
browser. This is a boolean variable which helps you determine whether or not Internet Explorer is active on the indicated page. - Add an If activity under the Element Exists activity. This is used to open Internet Explorer if it’s closed, and continue the workflow otherwise.
- In
the Condition field, write
browser=false. This condition is used to verify if the browser is opened or not, and perform other actions, based on its value. - Drag an Open Browser activity in the Then section. If the Condition is met (the browser is closed), then the Open Browser activity is used to open it, without affecting the workflow.
- In the Url field type
https://www.fakenamegenerator.com.
- Leave the Else section empty so that the workflow continues as expected if Internet Explorer is already opened on the indicated website.
- Run the workflow and notice one of the following:
- If Internet Explorer is closed - The user is informed that Internet Explorer is about to open so the workflow can continue. The browser opens, all expected data is gathered and written to the Excel file.
- If Internet Explorer is open - The workflow is executed as expected.
Download example
Updated 5 months ago
- Table of Contents
-
Properties
- Example of using the Try Catch activity
What kind of code does the try block of a try catch statement contain?
The try block includes the code that might generate an exception. The catch block includes the code that is executed when there occurs an exception inside the try block.
Which code block is executed within a try catch structure?
The try...catch statement is comprised of a try block and either a catch block, a finally block, or both. The code in the try block is executed first, and if it throws an exception, the code in the catch block will be executed.
What is try catch block?
The try statement allows you to define a block of code to be tested for errors while it is being executed. The catch statement allows you to define a block of code to be executed, if an error occurs in the try block.
Which type of catch block is used?
The catch block contains code that is executed if and when the exception handler is invoked. The runtime system invokes the exception handler when the handler is the first one in the call stack whose ExceptionType matches the type of the exception thrown.
| 
