Skip to content

Tag: Error Handling

Common PowerShell Exceptions

PowerShell Logo

Each specific exception in PowerShell is designed to handle a particular type of error or exceptional condition that may occur during script execution. It’s not feasible to provide an exhaustive list of all possible exceptions in PowerShell, as the language is highly extensible and allows for custom exceptions to be defined by users or modules.

Each exception type in PowerShell is typically defined within the System namespace, and some exceptions may have additional namespaces depending on their origin or context. When catching exceptions in PowerShell, you can either specify the fully qualified name of the exception class (including its namespace) or use the short name if it’s available in the current namespace.

For example, the ItemNotFoundException exception belongs to the System.Management.Automation namespace. So, you can catch it using either its fully qualified name [System.Management.Automation.ItemNotFoundException] or just ItemNotFoundException if you’re already in the System.Management.Automation namespace context.

PowerShell Exceptions

  • ItemNotFoundException: This exception is thrown when an attempt is made to access an item that does not exist, such as a file or directory.
  • CommandNotFoundException: Occurs when PowerShell cannot find a specified command. This can happen when trying to execute a command that doesn’t exist or isn’t available in the current environment.
  • ParameterBindingException: Thrown when there is an issue binding a parameter to a cmdlet or function. This can occur when the provided parameter values do not match the expected types or when required parameters are missing.
  • InvalidDataException: Indicates that the data supplied to a cmdlet or function is invalid. This can happen when providing input that does not meet the expected format or constraints.
  • InvalidOperationException: Typically occurs when an operation is performed that is not valid for the current state of the object. This can include trying to perform operations on closed or disposed objects.
  • UnauthorizedAccessException: Thrown when the user does not have permission to perform a particular operation. This can occur when trying to access or modify files or settings without the necessary permissions.
  • RuntimeException: This is a generic exception class that serves as the base class for all exceptions thrown by PowerShell. It typically indicates an unexpected error or problem during script execution.
  • ArgumentException: Indicates that one or more arguments provided to a cmdlet or function are invalid. This can include providing arguments with incorrect types or values.
  • ArgumentNullException: Thrown when a null argument is passed to a method that does not accept it. This can occur when passing null values to cmdlets or functions that expect non-null arguments.
  • FormatException: Occurs when the format of an argument does not meet the requirements of the cmdlet or function. This can include providing strings that cannot be parsed into the expected format.
  • PipelineStoppedException: Indicates that the pipeline has been stopped, typically due to an error or user intervention. This can occur when an error is encountered during pipeline execution.
  • ScriptCallDepthException: This exception occurs when the maximum script call depth has been exceeded. This can happen when scripts or functions recursively call themselves too many times.
  • NotSupportedException: Indicates that a particular operation is not supported by PowerShell. This can occur when trying to perform operations that are not implemented or allowed in the current environment.
  • TimeoutException: Thrown when an operation exceeds the specified timeout period. This can occur when executing long-running operations that take longer than expected to complete.
  • IOException: Thrown for I/O related errors, such as file or network access issues. This can occur when there are problems reading from or writing to files, directories, or network resources.
  • OutOfMemoryException: Indicates that the system has run out of memory to complete the operation. This can occur when scripts or processes consume more memory than is available.
  • PipelineClosedException: Indicates that the pipeline has been closed unexpectedly. This can occur when attempting to write to a closed pipeline or when a pipeline is closed due to an error.
  • ProviderNotFoundException: Thrown when a specified provider cannot be found. This can occur when trying to access a PowerShell provider that is not available in the current environment.
  • SessionStateUnauthorizedAccessException: Indicates that access to a session state variable is unauthorized. This can occur when trying to access or modify session state variables without the necessary permissions.
  • WildcardPatternException: Occurs when a wildcard pattern used in a command parameter is invalid. This can happen when providing wildcard patterns that contain syntax errors or are not properly formatted.

Example Usage:

try {
    # Attempt to access a file that doesn't exist
    $file = Get-Item "C:\Path\To\Nonexistent\File.txt"
    # If the file exists, display its name
    Write-Output "File found: $($file.FullName)"
catch [System.Management.Automation.ItemNotFoundException] {
    # Catch the ItemNotFoundException and handle it
    Write-Output "File not found: $($Error[0].Exception.Message)"
catch {
    # Catch any other exceptions
    Write-Output "An error occurred: $($_.Exception.Message)"

PowerShell $ErrorActionPreference Explained

In PowerShell, the $ErrorActionPreference variable controls how PowerShell responds to non-terminating errors. It determines the default behaviour when an error occurs within a script or command. Understanding the different options of $ErrorActionPreference is crucial for effective error handling.

Here are the different options and what each does:

  • Continue: This is the default value. When an error occurs, PowerShell displays the error message but continues executing the remaining commands in the script. It does not halt the script execution.
  • SilentlyContinue: PowerShell suppresses the error message and continues executing the script as if no error occurred. It does not display any error messages to the user. This option is useful when you want to handle errors programmatically without interrupting the script flow.
  • Stop: When an error occurs, PowerShell displays the error message and stops executing the script. It terminates the script execution immediately after encountering the error. This behaviour is useful when you want to ensure that any error is addressed before proceeding further.
  • Inquire: PowerShell prompts the user to choose whether to continue executing the script or not when an error occurs. This option allows for interactive error handling, where the user can decide how to proceed based on the error message.
  • Ignore: PowerShell ignores the error completely and continues executing the script without displaying the error message. It treats the error as if it didn’t occur. This option is not recommended for most scenarios as it can lead to unexpected behaviour and potential data loss.

To modify the $ErrorActionPreference variable, you can assign one of the above values to it. For example:

$ErrorActionPreference = "Stop"

This sets the error action preference to “Stop”, meaning PowerShell will halt script execution upon encountering an error.

You can also scope the $ErrorActionPreference variable to specific parts of your script using the Scope parameter:

$ErrorActionPreference = "Stop" -Scope Script

This sets the error action preference to “Stop” only within the current script scope.

By understanding and appropriately setting the $ErrorActionPreference, you can control how PowerShell handles errors within your scripts, ensuring they behave as expected and provide a better user experience.

Recommended Reading: Understanding Try/Catch Error Handling in PowerShell

Understanding Try/Catch Error Handling in PowerShell

PowerShell Logo

Error handling is a critical aspect of writing robust and reliable scripts in PowerShell. The try/catch statement is a powerful mechanism that allows you to gracefully handle errors that may occur during script execution. In this article, we’ll delve into how try/catch error handling works in PowerShell, explore various scenarios, and provide examples to illustrate its usage.

How Try/Catch Works

The try/catch statement in PowerShell allows you to monitor a block of code for errors.

Here’s how it works:

  • The code within the try block is executed.
  • If an error occurs within the try block, PowerShell immediately jumps to the catch block.
  • Inside the catch block, you can handle the error gracefully, log it, or take appropriate action.


try {
# Code block to monitor for errors
catch {
# Error handling code

Handling Specific Exceptions:

try {
    $result = 10 / 0  # Attempting to divide by zero
catch [System.DivideByZeroException] {
    Write-Host "Cannot divide by zero."
catch {
    Write-Host "An unexpected error occurred: $_"

In this example, the catch block specifically handles the DivideByZeroException. If any other type of exception occurs, it falls back to the generic catch block.

Handling Multiple Exceptions:

try {
    $file = Get-Content "nonexistentfile.txt"  # Attempting to read a nonexistent file
catch [System.IO.FileNotFoundException] {
    Write-Host "File not found: $($Error[0].Exception.Message)"
catch [System.UnauthorizedAccessException] {
    Write-Host "Access denied: $($Error[0].Exception.Message)"
catch {
    Write-Host "An unexpected error occurred: $_"

Here, the catch blocks handle different types of exceptions that may occur while attempting to read a file.

Using Finally Block:

try {
    # Code that may throw an error
catch {
    # Error handling code
finally {
    # Cleanup code that always executes, regardless of errors

The finally block is optional and executes whether an error occurs or not. It’s typically used for clean-up tasks such as closing files or releasing resources.

Scenarios for Error Handling

  • Network Operations: Handling timeouts or connection failures when making network requests.
  • File Operations: Dealing with file not found, access denied, or permission issues.
  • Database Operations: Managing errors when querying databases or executing SQL commands.
  • External Commands: Handling errors from external executables called within PowerShell scripts.
  • Input Validation: Validating user input and handling errors caused by invalid data.


The try/catch statement in PowerShell provides a structured and reliable way to handle errors in scripts. By anticipating potential issues and implementing appropriate error handling logic, you can make your scripts more robust and resilient to failures. Understanding how to use try/catch effectively empowers you to write PowerShell scripts that gracefully handle errors and maintain stability in various scenarios.

Recommended Reading: Top 20 Common PowerShell Exceptions

© 2024 - Powered by Coffee & Magic