POSTS

PowerShell advanced parameter behavior unexpected

May 27, 2010

I have been experimenting with parameter values from the pipeline and the processing behavior is slightly different when using piplines vs. parameterized values. It is easy enough to work around, but I wanted to make sure and explain the issue and one workaround.

The standard way of using a pipeline parameter is to do something like this:

param
(
    [parameter(Mandatory=$true,
    ValueFromPipeLine=$true)]
    [String[]]$item
)

In cases where you accept input from the pipeline or a single item as an input parameter this works fine.

"one","two" | .\AdvancedParameterScript.ps1
.\AdvancedParameterScript.ps1 -item "one"

However, it breaks when you try to specify an array of items using the parameter syntax. This happens because the process block happens once with the ‘item’ parameter containing an array of all of the values.

.\AdvancedParameterScript.ps1 -item "one"

Here is a simple script that I used to test it.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


param
(
    [parameter(Mandatory=$true,
    ValueFromPipeLine=$true)]
    [String[]]$item
)

  BEGIN
  {
      $i = 0;
  }

  PROCESS
  {
      $i++
      "Iteration:{0}" -f $i
      "Item type:{0}" -f $item.gettype()
      "Item length:{0}" -f $item.Length
      "Item value:{0}" -f $item
  }

Here is the output of the expected and problem case.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


C:\>"foo","bar" | .\AdvancedParameterTesting.ps1
Iteration:1
Item type:System.String[]
Item length:1
Item value:foo
Iteration:2
Item type:System.String[]
Item length:1
Item value:bar

C:\> .\AdvancedParameterTesting.ps1 -item "foo","bar"
Iteration:1
Item type:System.String[]
Item length:2
Item value:foo bar

You can see that in the second case the parameter is being assigned an array containing both values. The examples of pipelined input I have seen do not appear to expect this use case because most of them would fail.

Since the pipeline input is being sent to the PROCESS block as an array of length 1 we can easily work around the differences by using a foreach loop. It may seem silly to do this when expecting a single item, but it makes the processing behavior the same in all three cases.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


param
(
    [parameter(Mandatory=$true,
    ValueFromPipeLine=$true)]
    [String[]]$item
)

  BEGIN
  {
      $i = 0;
  }

  PROCESS
  {
      foreach ($_item in $item)
      {
          $i++
          "Iteration:{0}" -f $i
          "Item type:{0}" -f $_item.gettype()
          "Item length:{0}" -f $_item.Length
          "Item value:{0}" -f $_item
      }
  }

And the output:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


C:\> "foo","bar" | .\AdvancedParameterTesting2.ps1
Iteration:1
Item type:System.String
Item length:3
Item value:foo
Iteration:2
Item type:System.String
Item length:3
Item value:bar

C:\> .\AdvancedParameterTesting2.ps1 -item "foo","bar"
Iteration:1
Item type:System.String
Item length:3
Item value:foo
Iteration:2
Item type:System.String
Item length:3
Item value:bar

C:\>.\AdvancedParameterTesting2.ps1 -item "foo"
Iteration:1
Item type:System.String
Item length:3
Item value:foo