Understanding the Clean block in PowerShell

PowerShell, a powerful scripting language and automation framework, provides features that enhance script development and execution. Among these features is the clean block, a lesser-known yet beneficial component in PowerShell functions. This article explores the clean block, its purpose, and how to use it effectively in PowerShell scripts.

What is the Clean block?

The clean block, added in PowerShell version 7.3, allows you to define clean-up tasks that should be executed after the function completes, regardless of whether it completes successfully or encounters an error. It's part of PowerShell's robust resource management mechanism, ensuring that any resources allocated during the execution of a function are properly released.

Purpose of the Clean block

The primary purpose of the clean block is to provide functionality for clean-up logic. This logic can include:

  • Closing files or network connections
  • Releasing locks on resources
  • Deleting temporary files
  • Resetting environment variables or states
  • Etc.

When using the clean block, you ensure these critical tasks are performed even if an error occurs during the execution of the function, maintaining the integrity and stability of your scripts and the system.

Syntax and usage

The clean block is defined within a function using the clean keyword. Here's an example of a function with a clean block:

 1function Test-CleanBlock {
 2    [CmdletBinding()]
 3    param (
 4        [Parameter(ValueFromPipeline)]
 5        [string]$FilePath
 6    )
 8    BEGIN {
 9        # Initialization code
10        Write-Verbose -Message 'Begin block executed'
11    }
13    PROCESS {
14        # Main processing code
15        Write-Verbose -Message 'Process block executed'
17        if (-not (Test-Path -Path $FilePath -PathType Leaf)) {
18            throw "File not found: $FilePath"
19        }
20        # Simulate some processing
21        Write-Verbose -Message "Processing file: $FilePath"
22    }
24    END {
25        # Finalization code
26        Write-Verbose -Message 'End block executed'
27    }
29    CLEAN {
30        # Cleanup code
31        Write-Output 'Clean block executed' # Not displayed because the Clean block doesn't write to the success stream.
32        Write-Host 'Performing cleanup tasks...'
33        Write-Verbose -Message 'Clean block executed'
34        # Perform cleanup tasks such as closing files, releasing resources, etc.
35    }

In this example, the clean block is used to display a message indicating that the cleanup code is being executed. In a real-world scenario, you would replace this with actual cleanup tasks.

Run the Test-CleanBlock function with an invalid file path and specify the Verbose parameter:

1'does-not-exist' | Test-CleanBlock -Verbose

How does the clean block differ from the end block? Notice that the end block doesn't execute because the function throws an exception, but the clean block executes regardless:

1VERBOSE: Begin block executed
2VERBOSE: Process block executed
3Performing cleanup tasks...
4VERBOSE: Clean block executed
6Line |
7  18 |              throw "File not found: $FilePath"
8     |              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
9     | File not found: does-not-exist

A practical example

Let's consider a more practical example where the clean block is used to close a file handle:

 1function Read-FileContent {
 2    [CmdletBinding()]
 3    param (
 4        [Parameter(ValueFromPipeline)]
 5        [string]$FilePath
 6    )
 8    BEGIN {
 9        $fileStream = $null
10    }
12    PROCESS {
13        try {
14            $fileStream = [System.IO.File]::OpenRead($FilePath)
15            $reader = [System.IO.StreamReader]::new($fileStream)
16            $content = $reader.ReadToEnd()
17            Write-Output $content
18        } catch {
19            Write-Error -Message "Error reading file: $_"
20        }
21    }
23    CLEAN {
24        if ($fileStream) {
25            $fileStream.Close()
26            Write-Verbose -Message 'File stream closed'
27        }
28    }

Run the Read-FileContent function with a sample file and specify the Verbose parameter:

1Read-FileContent -FilePath sample.txt -Verbose

The clean block ensures that the file stream is closed after the function completes:

1Sample text...
3VERBOSE: File stream closed

In this example, the clean block ensures that the file stream is closed regardless of whether the file was read successfully or an error occurred. This prevents resource leaks and potential file access issues.

Benefits of using the Clean block

  • Automatic execution: The clean block is executed automatically after the end block, regardless of whether the function completes successfully or encounters an error.
  • Resource management: The clean block is ideal for managing files, network connections, or other system resources that must be released or reset.
  • Code clarity: Separates clean-up logic from the main execution and error handling, improving code readability and maintainability.


The clean block is a valuable feature in PowerShell functions, providing a reliable way to manage resource clean-up. By incorporating the clean block into your scripts, you can ensure that your PowerShell functions are robust and maintain system stability. Whether you're handling files, network connections, or other resources, the clean block can help you manage them effectively, contributing to more resilient PowerShell scripts.