Powershell Array parameter from pipline

Question

I'm trying to duplicate a typical powershell -Computername parameter that's available from the pipeline and as a normal parameter using CmdletBinding and ValueFromPipeline. My challenge is that I'm getting different results from specifying the parameter versus piping in values.

My code looks like this:

[CmdletBinding()]
param(
    [parameter(Mandatory=$true, ValueFromPipeline=$true)] [string[]]$ComputerName
 )

BEGIN {  "Begin script`n-----" }

PROCESS { 
    "  `$ComputerName '$ComputerName'"
    "  `$_ '$_'"
    "  +++ Count: " + $ComputerName.Count
    foreach($computer in $ComputerName) {
        "    `$computer '$computer'"
    }
    "  -----"
}

END { "Complete" }

When I run this using a pipeline, I get this:

PS> (1, 2, 3) | .\BPEParamTest.ps1
Begin script
-----
  $ComputerName '1'
  $_ '1'
  +++ Count: 1
    $computer '1'
  -----
  $ComputerName '2'
  $_ '2'
  +++ Count: 1
    $computer '2'
  -----
  $ComputerName '3'
  $_ '3'
  +++ Count: 1
    $computer '3'
  -----
Complete

However, when run with a parameter, I get different results:

PS> .\BPEParamTest.ps1 -ComputerName (1, 2, 3)
Begin script
-----
  $ComputerName '1 2 3'
  $_ ''
  +++ Count: 3
    $computer '1'
    $computer '2'
    $computer '3'
  -----
Complete

I do hope somebody comes back with a good answer. I've been banging my head against this for a couple days now as well. I noticed that if I don't have Begin/Process/End blocks and just include the code in a basic function it behaves differently as well, so I think it has to do with the blocks. — TheMadTechnician
– TheMadTechnician, Commented Jul 9, 2014 at 18:51
So my end result was to kill the pipeline usage, and just go with the parameter based computername array. This ends up being more along the lines of how several of the built in commands work such as get-service (pipeline is service name, not computername), get-process (pipeline is process name) and test-connection. These all use Computername with ByPropertyName stuff. End result is to run this with -ComputerName (Get-Content Servers.txt) rather then Get-Content Servers.txt | — Christopher G. Lewis
– Christopher G. Lewis, Commented Jul 14, 2014 at 15:39

Mike Shepard · Accepted Answer · 2014-07-10 02:24:35Z

3

I always use the following construction. This works for arrays in a parameter as well as from the pipeline:

[CmdletBinding()]
param(
    [parameter(Mandatory=$true, ValueFromPipeline=$true)] [string[]]$ComputerName
 )

process {
  foreach($computer in $computername){
      #do the stuff
  }

Full explanation: The process block is run once for each item in the pipeline, so that's how it handles lists on the pipeline (i.e. $computername is set to each item in turn). If you pass the values as a parameter, the $computername is set to the list which is why there's a loop.

edited Jul 10, 2014 at 2:24

answered Jul 9, 2014 at 19:06

Mike Shepard

18.4k7 gold badges59 silver badges72 bronze badges

Sign up to request clarification or add additional context in comments.

7 Comments

Bill_Stewart Over a year ago

This approach is less effective if the collection is large or expensive to gather.

Mike Shepard Over a year ago

I'm not sure what you mean. If you pipe in a list of things, the process block is run once for each item. They aren't collected at all. The loop is there for arrays presented on the command-line as arguments.

Bill_Stewart Over a year ago

And if the collection is expensive and passed as an argument, PowerShell gathers the whole collection before calling the function anyway. (I was thinking about foreach rather than the pipeline.)

Mike Shepard Over a year ago

Definitely agree about using foreach keyword with big collections.

Christopher G. Lewis Over a year ago

So this ends up working (incorrectly) like my example above - when a list of servers is piped to the script, PROCESS is called once per item in the pipeline, when called using the parameter, PROCESS is called once.

|

Bill_Stewart · Accepted Answer · 2014-07-09 18:52:43Z

0

.\BPEParamTest.ps1 -ComputerName (1, 2, 3) does not use the pipeline but rather a single input (a 3-element array). In contrast, (1, 2, 3) | .\BPEParamTest.ps1 uses the pipeline (3 separate inputs).

To work around this, you can check bound parameters and determine if there is pipeline input. Here is a short example:

function out-item {
  [CmdletBinding()]
  param(
    [Parameter(ValueFromPipeline=$TRUE)]
      $item
  )
  begin {
    $PipelineInput = -not $PSBoundParameters.ContainsKey("item")
    write-host "Pipeline input? $PipelineInput"
    $n = 0
  }
  process {
    if ($PipelineInput) {
      $_
      $n++
    }
    else {
      $item | foreach-object {
        $_
        $n++
      }
    }
  }
  end {
    write-host "Output $n item(s)"
  }
}

With this function, both 1,2,3 | out-item and out-item 1,2,3 produce the same output (except for the "Pipeline input?" part).

answered Jul 9, 2014 at 18:52

Bill_Stewart

24.9k5 gold badges55 silver badges70 bronze badges

2 Comments

Christopher G. Lewis Over a year ago

Main issue with this is the goofy-ness of having Process run once for parameter and multiple times for pipeline. You'd also have to have your main processing in a function: if ($PipelineInput) { DoStuff -computer $_ } else { $item | foreach-object { DoStuff -computer $item } } What would be ideal is somehow in the begin to convert the parameter to the pipeline. All of which goes to crap if someone calls it with both pipeline and parameter :-)

Bill_Stewart Over a year ago

The process block is not a problem (in fact, it's implicit in all functions if not declared). Also, a parameter cannot have both pipeline and parameter input in the same invocation; it's either-or by definition.

urbanSoft · Accepted Answer · 2023-06-01 12:39:44Z

Mike Shepard's answer does work. However, if you'd like to process only one element at a time in the process block I'd recommend the following approach:

Determine whether the script receives its input from pipeline or parameter ($PSCmdlet.MyInvocation.ExpectingInput).
If the input is provided by parameter pipe it to the very same script and exit processing (break).
If the input is provided by the pipeline keep on going.

Full example:

[CmdletBinding()]
param(
    [parameter(Mandatory=$true, ValueFromPipeline=$true)] [string[]]$ComputerName
 )

BEGIN {
  if (-Not $PSCmdlet.MyInvocation.ExpectingInput) {
    $ComputerName | & $PSCmdlet.MyInvocation.InvocationName
    break
  }
  "Begin script`n-----"
}

PROCESS { 
    "  `$ComputerName '$ComputerName'"
    "  `$_ '$_'"
    "  +++ Count: " + $ComputerName.Count
    foreach($computer in $ComputerName) {
        "    `$computer '$computer'"
    }
    "  -----"
}

END { "Complete" }

The output is the same for

PS> (1, 2, 3) | .\BPEParamTest.ps1

and

PS> .\BPEParamTest.ps1 -ComputerName (1, 2, 3)

jacobh12349 · Accepted Answer · 2025-05-27 16:49:41Z

-1

I tried using [object[]] and [array] in the parameter of my function, but it always only did 1 item at a time in the process section, so I found another way to do it like this.

[CmdletBinding()]
param(
    [Parameter(Mandatory = $true, ValueFromPipeline = $true)]
    $item
)
    
begin {
    $array = @()
}
    
process {
    $array += $item
}
    
end {
    # do stuff with array here
    # $array.
}

edited May 27 at 16:49

answered Apr 7 at 3:11

jacobh12349

191 silver badge3 bronze badges

Collectives™ on Stack Overflow

Powershell Array parameter from pipline

4 Answers 4

7 Comments

2 Comments

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

7 Comments

2 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related