Getting different results using the pipeline with functions

Question

I'm finding that passing objects to functions through the PowerShell pipeline converts them to string objects. If I pass the object as a parameter it keeps its type. To demonstrate:

I have the following PowerShell function which displays a object's type and value:

function TestFunction {
    param (
        [Parameter(
            Position=0,
            Mandatory=$true,
            ValueFromPipeline=$true
        )] $InputObject
    )

    Echo $InputObject.GetType().Name
    Echo $InputObject
}

I ran this script to test the function:

[string[]] $Array = "Value 1", "Value 2"

# Result outside of function.
Echo $Array.GetType().Name
Echo $Array
Echo ""

# Calling function with parameter.
TestFunction $Array
Echo ""

# Calling function with pipeline.
$Array | TestFunction

This produces the output:

String[]
Value 1
Value 2

String[]
Value 1
Value 2

String
Value 2

EDIT: How can I use the pipeline to pass an entire array to a function?

Answer 1

To process multiple items recieved via the pipeline you need a process block in your function:

function Test-Function {
    param (
        [Parameter(ValueFromPipeline=$true)] $Test
    )

    process {
        $Test.GetType().FullName
        $Test
    }
}

[string[]] $Array = "Value 1", "Value 2"
$Array | Test-Function

More info:

• get-help about_functions http://technet.microsoft.com/en-us/library/dd347712.aspx
• get-help about_Functions_Advanced http://technet.microsoft.com/en-us/library/dd315326.aspx

Answer 2

In addition to having a process block you also need to process each item in the array. It is needed when the array is passed as an argument, not via piping. Consider this:

function Test-Function 
{
    param (
        [Parameter(
            Position=0,
            Mandatory=$true,
            ValueFromPipeline=$true
        )] $InputObject
    )

    process
    {
        $InputObject.GetType().Name
    }
}

$Array = "Value 1","Value 2"
Test-Function $array

The result would be String[], which is probably not what you want. The following command will print the type of each item in the array no matter how the argument is passed:

function Test-Function 
{
    param (
        [Parameter(
            Position=0,
            Mandatory=$true,
            ValueFromPipeline=$true
        )] $InputObject
    )

    process
    {
        foreach($i in $InputObject)
        {
            $i.GetType().Name
        }
    }
}