PowerShell try catch with examples - SharePoint & Microsoft Power Platform Tutorials

In this PowerShell script tutorial, I will explain how to use try, catch, and finally, blocks in PowerShell with clear examples. I will show in detail, “PowerShell try catch with example“. Error handling is an essential aspect of scripting in PowerShell, as it allows you to gracefully manage and respond to unexpected issues that may arise during execution.

Table of Contents

Try Catch Finally in PowerShell

The try-catch-finally construct is a common error-handling pattern found in many programming languages. In PowerShell, it works as follows:

Try Block: This block contains the code that you want PowerShell to execute. If an error occurs within this block, PowerShell will stop executing the remaining code in the try block and move to the catch block.
Catch Block: The catch block is where you handle the error. You can have multiple catch blocks to handle different types of exceptions.
Finally Block: This block is optional and contains code that will run regardless of whether an error occurred or not in the PowerShell script. It’s typically used for cleanup operations.

Basic Syntax of try catch finally in PowerShell

Here’s the basic syntax for using try-catch-finally in PowerShell:

try {
    # Code that may cause an exception
}
catch {
    # Code to handle the exception
}
finally {
    # Code that will run regardless of an exception
}

Example of Try Catch in PowerShell

Let’s look at an example to understand how try-catch works in PowerShell.

Example 1: Catching a Specific Exception

try {
    Get-Content "C:\NonExistentFile.txt" -ErrorAction Stop
}
catch [System.Management.Automation.ItemNotFoundException] {
    Write-Host "The file was not found."
}

In this example, we’re trying to read a file that doesn’t exist. The -ErrorAction Stop parameter is used to ensure that any error is treated as a terminating error, which is necessary for it to be caught by the catch block. The catch block is configured to handle only the ItemNotFoundException type of exception, and it outputs a message indicating that the file was not found.

Example 2: Catching Any Exception

If you want to catch any type of exception, you can omit the specific exception type in the catch block:

try {
    Get-Content "C:\NonExistentFile.txt" -ErrorAction Stop
}
catch {
    Write-Host "An error occurred: $_"
}

The $_ variable represents the current exception object, which contains details about the error that occurred.

Example 3: Using Finally Block

Let’s add a finally block to the previous example to see how it works:

try {
    Get-Content "C:\NonExistentFile.txt" -ErrorAction Stop
}
catch {
    Write-Host "An error occurred: $_"
}
finally {
    Write-Host "This message is displayed regardless of an error."
}

In this example, the message in the finally block will be displayed whether or not an error occurred in the try block.

You can see the output in the screenshot below after I executed the PowerShell script using Visual Studio code.

Specific Exception Catching in PowerShell

Catching specific exceptions allows for a granular handling of different error conditions. PowerShell offers a range of exception types that one can catch individually.

Example of catching a specific exception:

try {
    # Code that might trigger an exception
} catch [System.UnauthorizedAccessException] {
    # Handle unauthorized access exception
} catch [System.IO.IOException] {
    # Handle IO exceptions
} catch {
    # Handle any other exceptions not previously caught
}

In this structure, exceptions are caught in a top-down approach, starting with the most specific to the most general.

Nested Try Catch Blocks in PowerShell

Nested try catch blocks in PowerShell allow for a hierarchal approach to error handling. Here are some key points:

Inner try catch: These can be used within an outer catch block to handle potential exceptions that might occur while handling another exception.
Error bubbling: If an exception is not handled in the inner try-catch block, it can be passed up to the outer catch block.

Example of nested try-catch in PowerShell:

try {
    # Outer try block
    # Code that might throw an exception
} catch {
    # Outer catch block
    try {
        # Inner try block to handle the exception
    } catch {
        # Inner catch block
    }
}

Multiple Catch Blocks in PowerShell

PowerShell allows for defining multiple catch blocks to handle different types of exceptions separately. This enables tailored responses to specific error conditions.

Catch type-specific exceptions: Each catch block can be written to handle a specific type of exception.
Execution order: PowerShell executes the first catch block that matches the thrown exception type.

Example of multiple catch blocks:

try {
    # Code that might throw different exceptions
} catch [System.UnauthorizedAccessException] {
    # Handle unauthorized access exceptions
} catch [System.IO.IOException] {
    # Handle I/O exceptions
} catch {
    # Handle any other exceptions
}

Logging and Reporting Errors in PowerShell

In PowerShell, structured error handling is crucial for both debugging and informing users about issues. Effective logging and reporting mechanisms ensure that errors are captured and communicated clearly.

Writing Error Logs

When a script encounters an error, it’s important to log it for future analysis. Using try and catch, one can direct PowerShell to write errors to a log file. The Out-File cmdlet is commonly used for this purpose.

try {
    # Code that might cause an error
} catch {
    $_ | Out-File -FilePath "C:\ErrorLogs\errorLog.txt" -Append
}

Custom Error Messages

To maintain clarity, custom error messages should be concise and informative. They can be specified within the catch block to replace or supplement default error messages.

try {
    # Code that might cause an error
} catch {
    "An error occurred: $($_.Exception.Message)" | Out-File -FilePath "C:\ErrorLogs\errorLog.txt" -Append
}

PowerShell try catch example

Now, let us check a real example of PowerShell try-catch example.

PowerShell’s try-catch block is essential for robust file operation scripts. It allows a script to handle errors gracefully, maintaining control flow and providing meaningful feedback to the user.

Reading Files with Error Handling

When reading files, one may encounter various errors, such as a file not being found or being inaccessible due to permissions. The following is a basic example of using a try-catch block to handle potential errors during file reading:

try {
    $content = Get-Content -Path "C:\example.txt" -ErrorAction Stop
} catch {
    Write-Host "An error occurred while reading the file: $_"
}

The -ErrorAction Stop parameter ensures that any non-terminating errors are treated as terminating, enabling the catch block to handle them accordingly.

Writing Files with Try Catch

Writing files also present a range of possible errors, such as disk write protection or a full disk. Below is an illustrative example of using try-catch blocks for file writing operations:

try {
    $content = "Sample data"
    $content | Out-File -FilePath "C:\example.txt" -ErrorAction Stop
} catch {
    Write-Host "An error occurred while writing to the file: $_"
}

By using the -ErrorAction Stop parameter with Out-File, the script ensures that any issues during the write process are caught, and an informative message is displayed to the user.

Best Practices for Using Try Catch in PowerShell

When implementing try-catch blocks in PowerShell, it’s important to follow best practices to ensure that your error handling is effective and your code is easy to maintain:

Use -ErrorAction Stop to make sure non-terminating errors are caught by the catch block.
Catch specific exceptions when possible to handle different errors appropriately.
Use the finally block for cleanup code that should run regardless of an error.
Use descriptive error messages to make it easier to understand and debug issues.

Conclusion

Error handling is an essential aspect of scripting in PowerShell. The try-catch block provides a robust method to capture and manage exceptions, ensuring scripts execute in a controlled manner, even when encountering runtime errors.

In this PowerShell tutorial, I have explained how to use try, catch, and finally in PowerShell with various examples.