Advanced functions (CmdletBinding) in PowerShell - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare an advanced function with CmdletBinding.

PowerShell

function Get-Greeting {
    [[1]()]
    param ()
    "Hello, World!"
}

Drag options to blanks, or click blank then click option'

AAlias

BParameter

COutputType

DCmdletBinding

Attempts:

3 left

💡 Hint

Common Mistakes

Using Parameter instead of CmdletBinding.

Forgetting the parentheses after CmdletBinding.

Placing CmdletBinding inside the param block.

The CmdletBinding attribute turns a function into an advanced function, enabling cmdlet features.

2fill in blank

medium

Complete the code to define a mandatory string parameter in an advanced function.

PowerShell

function Get-Greeting {
    [CmdletBinding()]
    param (
        [Parameter(Mandatory=[1])]
        [string]$Name
    )
    "Hello, $Name!"
}

Drag options to blanks, or click blank then click option'

A$true

B$false

CTrue

DFalse

Attempts:

3 left

💡 Hint

Common Mistakes

Using True or False without the $ sign.

Setting Mandatory to $false when the parameter should be required.

The Mandatory parameter attribute requires the user to provide a value; it uses $true to enable it.

3fill in blank

hard

Fix the error in the advanced function to correctly support pipeline input by property name.

PowerShell

function Get-Greeting {
    [CmdletBinding()]
    param (
        [Parameter(ValueFromPipelineByPropertyName=[1])]
        [string]$Name
    )
    process {
        "Hello, $Name!"
    }
}

Drag options to blanks, or click blank then click option'

A$false

BTrue

C$true

DFalse

Attempts:

3 left

💡 Hint

Common Mistakes

Using True or False without the $ sign.

Setting ValueFromPipelineByPropertyName to $false disables pipeline input.

To accept pipeline input by property name, ValueFromPipelineByPropertyName must be set to $true.

4fill in blank

hard

Fill both blanks to add a switch parameter and output a message when it is used.

PowerShell

function Get-Greeting {
    [CmdletBinding()]
    param (
        [switch]$VerboseMode
    )
    begin {
        if ([1]) {
            Write-Verbose "[2] mode is on."
        }
    }
    process {
        "Hello!"
    }
}

Drag options to blanks, or click blank then click option'

AVerboseMode

BVerbose

C$VerboseMode

D$Verbose

Attempts:

3 left

💡 Hint

Common Mistakes

Using variable names without $ in the if condition.

Confusing Verbose and VerboseMode parameter names.

The if statement needs the variable with $ sign ($VerboseMode). The Write-Verbose message is about VerboseMode parameter.

5fill in blank

hard

Fill all three blanks to define an advanced function with a string parameter, pipeline input, and output type.

PowerShell

function Get-Greeting {
    [[1]()]
    [OutputType([3])]
    param (
        [Parameter(ValueFromPipelineByPropertyName=[2])]
        [string]$Name
    )
    process {
        "Hello, $Name!"
    }
}

Drag options to blanks, or click blank then click option'

ACmdletBinding

B$true

C[string]

DParameter

Attempts:

3 left

💡 Hint

Common Mistakes

Using Parameter instead of CmdletBinding.

Using False instead of $true for pipeline input.

Not specifying output type as [string].

CmdletBinding makes the function advanced, $true enables pipeline input by property name, and [string] declares the output type.

Practice

1. What is the main purpose of using [CmdletBinding()] in a PowerShell function?

easy

A. To define global variables inside the function

B. To automatically run the function in the background

C. To disable parameter validation

D. To make the function behave like a built-in cmdlet with advanced features

Solution

1. Step 1: Understand CmdletBinding purpose

   [CmdletBinding()] adds cmdlet-like features such as common parameters and better error handling.

2. Step 2: Compare options

   Options A, C, and D do not describe what CmdletBinding does. It does not define globals, disable validation, or run background tasks.

3. Final Answer:

   To make the function behave like a built-in cmdlet with advanced features -> Option D

4. Quick Check:

   CmdletBinding enables cmdlet features = B [OK]

Hint: CmdletBinding makes functions act like real cmdlets [OK]

Common Mistakes:

• Thinking CmdletBinding defines variables
• Assuming it disables validation
• Believing it runs functions in background

2. Which of the following is the correct syntax to declare an advanced function with CmdletBinding and a mandatory parameter Name?

easy

A. function Get-User { [CmdletBinding()] param([Parameter(Mandatory=$true)][string]$Name) }

B. function Get-User { param([string]$Name) Mandatory }

C. function Get-User { param([Parameter(Mandatory=$true)][string]$Name) [CmdletBinding()] }

D. function Get-User { param([string]$Name) [CmdletBinding()] }

Solution

1. Step 1: Identify correct CmdletBinding placement

   [CmdletBinding()] must appear before param() block in the function.

2. Step 2: Check parameter declaration

   Mandatory parameter requires [Parameter(Mandatory=$true)] attribute inside param(). function Get-User { [CmdletBinding()] param([Parameter(Mandatory=$true)][string]$Name) } correctly places both.

3. Final Answer:

   function Get-User { [CmdletBinding()] param([Parameter(Mandatory=$true)][string]$Name) } -> Option A

4. Quick Check:

   CmdletBinding before param, mandatory attribute inside param = D [OK]

Hint: Put [CmdletBinding()] before param() with attributes inside param [OK]

Common Mistakes:

• Placing CmdletBinding after param
• Missing Mandatory attribute syntax
• Using 'Mandatory' keyword alone

3. What will be the output of this PowerShell advanced function when called as Get-Greeting -Name 'Alice'?

function Get-Greeting {
  [CmdletBinding()]
  param(
    [Parameter(Mandatory=$true)]
    [string]$Name
  )
  Write-Output "Hello, $Name!"
}

medium

A. "Hello, Alice!"

B. Error: Missing mandatory parameter

C. "Hello, $Name!"

D. No output

Solution

1. Step 1: Understand parameter passing

   The function requires a mandatory string parameter Name, which is provided as 'Alice'.

2. Step 2: Evaluate output statement

   Write-Output uses double quotes, so $Name is replaced by 'Alice', producing "Hello, Alice!".

3. Final Answer:

   "Hello, Alice!" -> Option A

4. Quick Check:

   Mandatory parameter passed, string interpolation works = C [OK]

Hint: Double quotes expand variables, mandatory param given = output shown [OK]

Common Mistakes:

• Confusing single vs double quotes
• Expecting error despite providing parameter
• Thinking variable won't expand

4. Identify the error in this advanced function code snippet:

function Test-Function {
  param(
    [Parameter(Mandatory=$true)]
    [string]$InputValue
  )
  [CmdletBinding()]
  Write-Output $InputValue
}

medium

A. Write-Output cannot be used inside functions

B. Mandatory attribute cannot be used with strings

C. [CmdletBinding()] must be before param() block

D. Function name cannot contain hyphens

Solution

1. Step 1: Check CmdletBinding placement

   [CmdletBinding()] must appear before the param() block, but here it is after.

2. Step 2: Validate other parts

   Mandatory attribute is valid for strings, Write-Output is allowed, and hyphens in function names are allowed.

3. Final Answer:

   [CmdletBinding()] must be before param() block -> Option C

4. Quick Check:

   CmdletBinding before param required = A [OK]

Hint: CmdletBinding always goes before param() [OK]

Common Mistakes:

• Placing CmdletBinding after param
• Thinking Mandatory is invalid for strings
• Believing Write-Output is disallowed

5. You want to create an advanced function that accepts a switch parameter -Verbose to show extra messages only when the switch is used. Which code snippet correctly implements this behavior?

hard

A. function Show-Info {
[CmdletBinding()]
param()
if ($Verbose) { Write-Output 'Verbose mode ON' }
else { Write-Output 'Normal mode' }
}

B. function Show-Info {
[CmdletBinding()]
param([switch]$Verbose)
if ($PSBoundParameters.ContainsKey('Verbose')) { Write-Output 'Verbose mode ON' }
else { Write-Output 'Normal mode' }
}

C. function Show-Info {
param([switch]$Verbose)
[CmdletBinding()]
if ($Verbose) { Write-Output 'Verbose mode ON' }
else { Write-Output 'Normal mode' }
}

D. function Show-Info {
[CmdletBinding()]
param([bool]$Verbose)
if ($Verbose -eq $true) { Write-Output 'Verbose mode ON' }
else { Write-Output 'Normal mode' }
}

Solution

1. Step 1: Confirm CmdletBinding and param order

   [CmdletBinding()] must come before param(). Only options A, B, and D do this correctly; C is wrong.

2. Step 2: Check switch parameter usage

   Switch parameters are declared as [switch]$Verbose. To detect if switch was used, check $PSBoundParameters.ContainsKey('Verbose') or $Verbose directly. function Show-Info { [CmdletBinding()] param([switch]$Verbose) if ($PSBoundParameters.ContainsKey('Verbose')) { Write-Output 'Verbose mode ON' } else { Write-Output 'Normal mode' } } uses $PSBoundParameters which is reliable.

3. Step 3: Evaluate parameter type

   function Show-Info { [CmdletBinding()] param([bool]$Verbose) if ($Verbose -eq $true) { Write-Output 'Verbose mode ON' } else { Write-Output 'Normal mode' } } uses [bool] which is not the recommended type for switches; switches are special and should use [switch].

4. Final Answer:

   function Show-Info { [CmdletBinding()] param([switch]$Verbose) if ($PSBoundParameters.ContainsKey('Verbose')) { Write-Output 'Verbose mode ON' } else { Write-Output 'Normal mode' } } -> Option B

5. Quick Check:

   CmdletBinding before param, switch param, check $PSBoundParameters = A [OK]

Hint: Use [switch] param and check $PSBoundParameters['Verbose'] [OK]

Common Mistakes:

• Placing CmdletBinding after param
• Using [bool] instead of [switch]
• Checking switch with just $Verbose without $PSBoundParameters