WhatIf and Confirm support in PowerShell - Practice Problems & Coding Challenges

Challenge - 5 Problems

💻 Command Output

intermediate

What is the output when using -WhatIf with Remove-Item?

Consider the following PowerShell command:

Remove-Item -Path 'C:\Temp\file.txt' -WhatIf

What will this command output?

PowerShell

Remove-Item -Path 'C:\Temp\file.txt' -WhatIf

A Prompt asking 'Are you sure you want to delete C:\Temp\file.txt?'

B What if: Performing the operation "Remove File" on target "C:\Temp\file.txt".

C Error: Remove-Item does not support -WhatIf parameter.

D File 'C:\Temp\file.txt' is deleted silently with no output.

💡 Hint

The -WhatIf parameter shows what would happen without making changes.

The -WhatIf parameter simulates the command and outputs a message describing the action without performing it.

💻 Command Output

intermediate

What happens when Confirm is set to true on Stop-Process?

Given the command:

Stop-Process -Name notepad -Confirm:$true

What will PowerShell do when this runs?

PowerShell

Stop-Process -Name notepad -Confirm:$true

A It throws an error because -Confirm does not accept boolean values.

B It stops all notepad processes immediately without asking.

C It prompts the user to confirm stopping each notepad process.

D It silently ignores the command without stopping any process.

💡 Hint

The -Confirm parameter controls user confirmation prompts.

Setting -Confirm:$true forces PowerShell to ask for confirmation before stopping each process.

📝 Syntax

advanced

Identify the correct way to add WhatIf support in a custom function

You want to add WhatIf support to this PowerShell function:

function Remove-MyFile {
  param([string]$Path)
  Remove-Item -Path $Path
}

Which option correctly adds WhatIf support?

PowerShell

function Remove-MyFile {
  param([string]$Path)
  Remove-Item -Path $Path
}

A Add [CmdletBinding(SupportsShouldProcess=$true)] above function and use if ($PSCmdlet.ShouldProcess($Path)) { Remove-Item -Path $Path }

B Add param([switch]$WhatIf) and inside function use if ($WhatIf) { Write-Output "WhatIf: $Path" } else { Remove-Item -Path $Path }

C Add -WhatIf parameter to Remove-Item call directly without changes to function declaration

D Add SupportsWhatIf=$true in param block and call Remove-Item normally

💡 Hint

WhatIf support requires CmdletBinding and ShouldProcess method.

To support -WhatIf, the function must declare CmdletBinding with SupportsShouldProcess and call ShouldProcess before action.

🔧 Debug

advanced

Why does this function not prompt for confirmation despite -Confirm:$true?

Given this function:

function Remove-MyFile {
  param([string]$Path)
  Remove-Item -Path $Path -Confirm:$true
}

When calling Remove-MyFile -Path 'C:\temp\file.txt' -Confirm:$true, no confirmation prompt appears. Why?

PowerShell

function Remove-MyFile {
  param([string]$Path)
  Remove-Item -Path $Path -Confirm:$true
}

A PowerShell disables confirmation prompts by default.

B Remove-Item does not support -Confirm parameter.

C The -Confirm parameter must be passed to the function, not inside Remove-Item.

D The function does not declare CmdletBinding with SupportsShouldProcess, so -Confirm is ignored.

💡 Hint

Confirm support requires CmdletBinding with SupportsShouldProcess in functions.

Without CmdletBinding(SupportsShouldProcess=$true), the function does not support -Confirm and the parameter is ignored.

🚀 Application

expert

How to implement both WhatIf and Confirm support in a custom PowerShell function?

You want to create a PowerShell function that deletes a file and supports both -WhatIf and -Confirm parameters natively. Which code snippet correctly implements this?

A

[CmdletBinding(SupportsShouldProcess=$true, ConfirmImpact='Medium')]
param([string]$Path)
if ($PSCmdlet.ShouldProcess($Path)) {
  Remove-Item -Path $Path
}

B

param([string]$Path, [switch]$WhatIf, [switch]$Confirm)
if ($WhatIf) { Write-Output "WhatIf: Remove $Path" } elseif ($Confirm) { Read-Host 'Confirm deletion?'; Remove-Item -Path $Path } else { Remove-Item -Path $Path }

C

[CmdletBinding()]
param([string]$Path)
Remove-Item -Path $Path -WhatIf:$WhatIf -Confirm:$Confirm

D

param([string]$Path)
Remove-Item -Path $Path -WhatIf -Confirm

💡 Hint

Use CmdletBinding with SupportsShouldProcess and call ShouldProcess method.

To support -WhatIf and -Confirm, the function must declare CmdletBinding with SupportsShouldProcess and call ShouldProcess before performing the action.

Practice

1. What does the -WhatIf parameter do when used with a PowerShell command?

easy

A. It logs the command output to a file automatically.

B. It forces the command to run without any confirmation prompts.

C. It cancels the command immediately after starting.

D. It shows what the command would do without actually performing the action.

Solution

1. Step 1: Understand the purpose of -WhatIf

   The -WhatIf parameter simulates the command's effect without making changes.

2. Step 2: Compare options to the definition

   Only It shows what the command would do without actually performing the action. correctly describes this simulation behavior.

3. Final Answer:

   It shows what the command would do without actually performing the action. -> Option D

4. Quick Check:

   -WhatIf simulates action = D [OK]

Hint: WhatIf means "show only, don't do" [OK]

Common Mistakes:

• Thinking -WhatIf runs the command fully
• Confusing -WhatIf with -Confirm
• Assuming it cancels the command

2. Which of the following is the correct way to add confirmation support to a PowerShell function?

easy

A. Add [CmdletBinding(SupportsShouldProcess=$true, ConfirmImpact='Medium')] above the function.

B. Add param([switch]$Confirm) inside the function body.

C. Use Write-Host 'Confirm?' inside the function.

D. Add -Confirm inside the function name.

Solution

1. Step 1: Recall how to enable Confirm support

   PowerShell functions use [CmdletBinding(SupportsShouldProcess=$true, ConfirmImpact='Medium')] to support -WhatIf and -Confirm.

2. Step 2: Check each option

   Only Add [CmdletBinding(SupportsShouldProcess=$true, ConfirmImpact='Medium')] above the function. correctly shows the attribute syntax to enable confirmation support.

3. Final Answer:

   Add [CmdletBinding(SupportsShouldProcess=$true, ConfirmImpact='Medium')] above the function. -> Option A

4. Quick Check:

   Enable Confirm with CmdletBinding attribute = C [OK]

Hint: Use CmdletBinding attribute to enable Confirm support [OK]

Common Mistakes:

• Adding param switch instead of CmdletBinding
• Using Write-Host for confirmation prompts
• Trying to put -Confirm in function name

3. Given this function with Confirm support:

[CmdletBinding(SupportsShouldProcess=$true)]
function Remove-File {
  param([string]$Path)
  if ($PSCmdlet.ShouldProcess($Path)) {
    Remove-Item $Path
  }
}

What happens when you run Remove-File -Path 'test.txt' -WhatIf?

medium

A. It shows a message about deleting 'test.txt' but does not delete it.

B. It deletes 'test.txt' without asking.

C. It asks for confirmation before deleting 'test.txt'.

D. It throws an error because -WhatIf is not supported.

Solution

1. Step 1: Understand the function's use of ShouldProcess

   The function calls $PSCmdlet.ShouldProcess($Path), which respects -WhatIf and -Confirm.

2. Step 2: Effect of running with -WhatIf

   Using -WhatIf causes ShouldProcess to return false but show what would happen, so Remove-Item is not called.

3. Final Answer:

   It shows a message about deleting 'test.txt' but does not delete it. -> Option A

4. Quick Check:

   -WhatIf shows action, no delete = B [OK]

Hint: ShouldProcess respects -WhatIf to simulate actions [OK]

Common Mistakes:

• Assuming -WhatIf deletes files
• Confusing -WhatIf with -Confirm
• Thinking function lacks support for -WhatIf

4. You wrote this function:

function Delete-Data {
  param([string]$File)
  if ($PSCmdlet.ShouldProcess($File)) {
    Remove-Item $File
  }
}

But when you run Delete-Data -File 'data.txt' -Confirm, it does not ask for confirmation. Why?

medium

A. You must add -WhatIf to enable confirmation.

B. The function lacks [CmdletBinding(SupportsShouldProcess=$true)] attribute.

C. The param block is missing [switch]$Confirm parameter.

D. Remove-Item does not support confirmation.

Solution

1. Step 1: Check function attributes for Confirm support

   The function is missing [CmdletBinding(SupportsShouldProcess=$true)], which enables -Confirm and -WhatIf support.

2. Step 2: Understand effect of missing attribute

   Without this attribute, the function ignores -Confirm and does not prompt.

3. Final Answer:

   The function lacks [CmdletBinding(SupportsShouldProcess=$true)] attribute. -> Option B

4. Quick Check:

   Missing CmdletBinding disables Confirm = A [OK]

Hint: Add CmdletBinding to enable -Confirm prompts [OK]

Common Mistakes:

• Thinking -WhatIf enables confirmation
• Adding Confirm parameter manually
• Assuming Remove-Item disables confirmation

5. You want to write a PowerShell function that deletes files but only after confirmation, and also supports -WhatIf. Which code snippet correctly implements this?

hard

A. [CmdletBinding()]
function Remove-MyFile {
param([string]$Path)
Remove-Item $Path -Confirm
}

B. function Remove-MyFile {
param([string]$Path, [switch]$Confirm)
if ($Confirm) {
Remove-Item $Path
}
}

C. [CmdletBinding(SupportsShouldProcess=$true, ConfirmImpact='High')]
function Remove-MyFile {
param([string]$Path)
if ($PSCmdlet.ShouldProcess($Path, 'Remove')) {
Remove-Item $Path
}
}

D. function Remove-MyFile {
param([string]$Path)
Remove-Item $Path -WhatIf
}

Solution

1. Step 1: Identify correct use of CmdletBinding and ShouldProcess

   [CmdletBinding(SupportsShouldProcess=$true, ConfirmImpact='High')] function Remove-MyFile { param([string]$Path) if ($PSCmdlet.ShouldProcess($Path, 'Remove')) { Remove-Item $Path } } uses [CmdletBinding(SupportsShouldProcess=$true, ConfirmImpact='High')] and calls $PSCmdlet.ShouldProcess, enabling both -Confirm and -WhatIf support.

2. Step 2: Check other options for missing or incorrect usage

   function Remove-MyFile { param([string]$Path, [switch]$Confirm) if ($Confirm) { Remove-Item $Path } } lacks CmdletBinding and misuses Confirm as a manual switch. [CmdletBinding()] function Remove-MyFile { param([string]$Path) Remove-Item $Path -Confirm } lacks SupportsShouldProcess and forces -Confirm on Remove-Item only. function Remove-MyFile { param([string]$Path) Remove-Item $Path -WhatIf } always uses -WhatIf, which is not correct for actual deletion.

3. Final Answer:

   [CmdletBinding(SupportsShouldProcess=$true, ConfirmImpact='High')] with $PSCmdlet.ShouldProcess -> Option C

4. Quick Check:

   CmdletBinding + ShouldProcess = A [OK]

Hint: Use CmdletBinding and ShouldProcess for full Confirm and WhatIf [OK]

Common Mistakes:

• Forgetting CmdletBinding attribute
• Manually adding Confirm switch parameter
• Always using -WhatIf inside function