PowerShell advanced function output PipelineVariable doesn't work - function

I created an advanced function to get the mac address from a VM running on VMware ESXi.
function Get-MacFromVm {
[CmdletBinding(SupportsShouldProcess=$true)]
Param(
# The name of the VM of which we want to obtain the mac address.
[Parameter(Mandatory=$true,
ValueFromPipeline=$true,
ValueFromPipelineByPropertyName=$true)]
[string[]]
$Name
)
Begin {}
Process {
foreach ($item in $Name) {
if ($PSCmdlet.ShouldProcess($item, "Getting the mac address")) {
Get-VM $item -PipelineVariable vm |
Get-NetworkAdapter |
Select-Object #{n="Name"; e={$vm.Name}},
#{n="ClientId"; e={$_.MacAddress -replace ":","-"}}
}
}
}
End {}
}
So far everything works perfect.
I can use it in any of the following ways and get results back.
It accepts either a single or array of string via the named parameter or as pipeline input.
Get-MacFromVm -Name "playground"
Get-MacFromVm -Name "playground", "DC01"
"playground", "DC01" | Get-MacFromVm
The output is a [PSCustomObject] with 2 properties, a Name and the ClientId.
Now the problem starts when I want to chain the result to multiple other cmdlets by using the -PipelineVariable parameter.
Normally I should be able to use it like this:
Get-MacFromVm -Name "playground" -PipelineVariable pv | % {$pv}
But it doesn't show me any results back. If i substitute the $pv with $_ it does show the correct result, but I cannot use that automatic variable 2 or 3 cmdlets farther in the pipeline chain.
Although I can solve this by using the -OutVariable and/or split it into multiple lines.
I want to know why this doesn't work, I want to know what I'm missing here.

I have no experience with -PipelineVariable parameter. So, I took this as an opportunity to learn about the -PipelineVariable parameter:
Because I do not have easy access to VMs either, I simulated the function as follows:
Function Get-MacFromVm {
[CmdletBinding(SupportsShouldProcess=$true)]
Param(
[Parameter(Mandatory=$true,
ValueFromPipeline=$true,
ValueFromPipelineByPropertyName=$true)]
[string[]]
$Name
)
Function MacAddress {(1..4 | ForEach {'{0:x2}' -f (Get-Random -Min 0 -Max 255)}) -Join ":"}
Function Get-VM {[cmdletbinding()] Param ($Name) [pscustomobject]#{Name = $Name; MacAddress = (MacAddress)}}
ForEach ($Item in $Name) {
If ($PSCmdlet.ShouldProcess($Item, "Getting the mac address")) {
Get-VM $item -PipelineVariable vm |
Select-Object #{n="Name"; e={$vm.Name}}, #{n="ClientId"; e={$_.MacAddress -replace ":","-"}}
}
}
}
But I am not able to reproduce the issue:
PS C:\> Get-MacFromVm -Name "playground", "DC01" -PipelineVariable pv | % {$pv}
Name ClientId
---- --------
playground 3c-23-55-c4
DC01 4f-38-42-a7
So I wonder if this simulated function also works for you.
If yes, maybe you can find the differences with a real VM object.
Knowing PowerShell, I would question whether there is nothing outputted or nothing displayed. So what happens if you just output a single property:
Get-MacFromVm -Name "playground" -PipelineVariable pv | % {$pv.Name}
Or:
Get-MacFromVm -Name "playground" -PipelineVariable pv | % {$pv.GetType()}
Does this return a "You cannot call a method on a null-valued expression." error?
Update 30 October 2019
As per mklement0 comment:
The reason you're not seeing the bug is that your function, due to not using begin / process / end blocks, implicitly runs in the end block, and the very first invocation of any of these script blocks is captured in the pipeline variable, but not the output from subsequent script blocks calls, which would happen with a function that has a process block.
Meaning the correct simulation should be:
Function Get-MacFromVm {
[CmdletBinding(SupportsShouldProcess=$true)]
Param(
[Parameter(Mandatory=$true,
ValueFromPipeline=$true,
ValueFromPipelineByPropertyName=$true)]
[string[]]
$Name
)
Begin {
Function MacAddress {(1..4 | ForEach {'{0:x2}' -f (Get-Random -Min 0 -Max 255)}) -Join ":"}
Function Get-VM {[cmdletbinding()] Param ($Name) [pscustomobject]#{Name = $Name; MacAddress = (MacAddress)}}
}
Process {
ForEach ($Item in $Name) {
If ($PSCmdlet.ShouldProcess($Item, "Getting the mac address")) {
Get-VM $item -PipelineVariable vm |
Select-Object #{n="Name"; e={$vm.Name}}, #{n="ClientId"; e={$_.MacAddress -replace ":","-"}}
}
}
}
}
Which indeed doesn't give any result for the PipelineVariable:
PS C:\> Get-MacFromVm -Name "playground", "DC01" -PipelineVariable pv | % {$pv}
PS C:\>
While the current item ($_) does:
PS C:\> Get-MacFromVm -Name "playground", "DC01" -PipelineVariable pv | % {$_}
Name ClientId
---- --------
playground e7-b5-a0-31
DC01 0f-ed-94-cc

Related

Can't call piped properties in a function. Powershell

So I'm trying to create a "download" function that uses a piped object property to determine a download method (sftp or http). Then either create an sftp script for putty/winscp or curl the http url. I am defining objects as follows:
#WinSCP
$winscp = new-object psobject
$winscp | add-member noteproperty name "WinSCP"
$winscp | add-member noteproperty dltype "http"
$winscp | add-member noteproperty file "winscp.exe"
$winscp | add-member noteproperty url "https://cdn.winscp.net/files/WinSCP-5.17.8-Setup.exe"
$winscp | add-member noteproperty path "$env:ProgramFiles(x86)\WinSCP"
$winscp | add-member noteproperty install 'msiexec /i "$DataPath\$winscp.file" /quiet /norestart'
#Database
$db = new-object psobject
$db | add-member noteproperty name "Client Database"
$db | add-member noteproperty dltype "sftp"
$db | add-member noteproperty file "database_"
$db | add-member noteproperty ver "check"
$db | add-member noteproperty ext ".csv"
$db | add-member noteproperty dir "db"
#DatabaseVersion
$db_ver = new-object psobject
$db_ver | add-member noteproperty name "Database Version File"
$db_ver | add-member noteproperty dltype "sftp"
$db_ver | add-member noteproperty file "current_version.txt"
$db_ver | add-member noteproperty dir "db"
Currently I'm having issues with the $Input variable within the function. It can only be used once and does not translate into an if statement. Since it contains an object with multiple properties, it needs converted to a new object within the function first I think. I'm new to powershell and haven't found a way of doing this yet. Here is the function I made and am trying to use:
function Download () {
#HTTP Download Method
if ($input.dltype -eq "http") {
curl $input.url -O $DataPath\$input.file
#HTTP Success or Error
$curlResult = $LastExitCode
if ($curlResult -eq 0)
{
Write-Host "Successfully downloaded $input.name"
}
else
{
Write-Host "Error downloading $input.name"
}
pause
}
#SFTP Download Method
if ($input.dltype -eq "sftp") {
sftpPassCheck
#Detect if version required
if ($input.ver = "check") {
#Download the objects version file
"$+$Input+_ver" | Download
#Update the object's ver property
$input.ver = [IO.File]::ReadAllText("$DataPath\current_version.txt")
#Build the new filename
$input.file = "$input.file"+"$input.ver"+"$input.ext"
#Delete the version file
Remove-Item "$DataPath\current_version.txt"
}
& "C:\Program Files (x86)\WinSCP\WinSCP.com" `
/log="$DataPath\SFTP.log" /ini=nul `
/command `
"open sftp://ftpconnector:$script:sftp_pass#$input.ip/ -hostkey=`"`"ssh-ed25519 255 SETvoRlAT0/eJJpRhRRpBO5vLfrhm5L1mRrMkOiPS70=`"`" -rawsettings ProxyPort=0" `
"cd /$input.dir" `
"lcd $DataPath" `
"get $input.file" `
"exit"
#SFTP Success or Error
$winscpResult = $LastExitCode
if ($winscpResult -eq 0)
{
Write-Host "Successfully downloaded $input.name"
}
else
{
Write-Host "Error downloading $input.name"
}
}
}
I'm probably missing something simple but I'm clueless at this point. Oh usage should be:
WinSCP | download
The proper way to bind input from the pipeline to a function's parameters is to declare an advanced function - see about_Functions_Advanced_Parameters and the implementation in the bottom section of this answer.
However, in simple cases a filter will do, which is a simplified form of a function that implicitly binds pipeline input to the automatic $_ variable and is called for each input object:
filter Download {
if ($_.dltype -eq "http") {
# ...
}
}
$input is another automatic variable, which in simple (non-advanced) functions is an enumerator for all pipeline input being received and must therefore be looped over.
That is, the following simple function is the equivalent of the above filter:
function Download {
# Explicit looping over $input is required.
foreach ($obj in $input) {
if ($obj.dltype -eq "http") {
# ...
}
}
}
If you do want to turn this into an advanced function (note that I've changed the name to conform to PowerShell's verb-noun naming convention):
function Invoke-Download {
param(
# Declare a parameter explicitly and mark it as
# as pipeline-binding.
[Parameter(ValueFromPipeline, Mandatory)]
$InputObject # Not type-constraining the parameter implies [object]
)
# The `process` block is called for each pipeline input object
# with $InputObject referencing the object at hand.
process {
if ($InputObject.dltype -eq "http") {
# ...
}
}
}
mklement0 is spot on - $input is not really meant to used directly, and you're probably much better off explicitly declaring your input parameters!
In addition to the $InputObject pattern shown in that answer, you can also bind input object property values to parameters by name:
function Download
{
param(
[Parameter(ValueFromPipelineByPropertyName = $true)]
[Alias('dltype')]
[string]$Protocol = 'http'
)
process {
Write-Host "Choice of protocol: $Protocol"
}
}
Notice that although the name of this parameter is $Protocol, the [Alias('dltype')] attribute will ensure that the value of the dltype property on the input object is bound.
The effect of this is:
PS ~> $WinSCP,$db |Download
Choice of protocol: http
Choice of protocol: sftp
Keep repeating this pattern for any required input parameter - declare a named parameter mapped to property names (if necessary), and you might end up with something like:
function Download
{
[CmdletBinding()]
param(
[Parameter(ValueFromPipelineByPropertyName = $true)]
[ValidateSet('sftp', 'http')]
[Alias('dltype')]
[string]$Protocol,
[Parameter(ValueFromPipelineByPropertyName = $true)]
[Alias('dir')]
[string]$Path = $PWD,
[Parameter(Mandatory = $true, ValueFromPipelineByPropertyName = $true)]
[Alias('url','file')]
[string]$Uri
)
process {
Write-Host "Downloading $Uri to $Path over $Protocol"
}
}
Now you can do:
PS ~> $WinSCP,$db |Download
Downloading https://cdn.winscp.net/files/WinSCP-5.17.8-Setup.exe to C:\Program Files(x86)\WinSCP over http
Downloading database_ to db over sftp
We're no longer dependent on direct access to $input, $InputObject or $_, nice and clean.
Please see the about_Functions_Advanced_Parameters help file for more information about parameter declaration.

powershell use of where-object within script function not working

I'm trying to enable my powershell profile script with a function that will let me do literal and wildcard searches for the presence of a function in my current powershell terminal session.
Within my powershell profile script [ $env:userprofile\Documents\WindowsPowerShell\Microsoft.PowerShell_profile.ps1 ] i've created the following function.
function Get-Fnc {
#Get-ChildItem function:\ | Where-Object { $_.Name -like "$args" }
Get-ChildItem function:\$args
}
Using the commented out line Get-ChildItem function:\ | Where-Object { $_.Name -like "$args" } doesn't work even though i can use that on the command line, e.g. Get-ChildItem function:\ | Where-Object { $_.Name -like "get-*" } it works as expected. Using the uncommented line Get-ChildItem function:\$args works both in the profile script function and the command line, e.g. Get-ChildItem function:\get-*.
Searching on net and in stackoverflow i've not been able to find any details on gotchas around making use of output piping | to another cmdlet and/or use of the Where-Object cmdlet within functions to determine how to make it work. Any insights on how to make output piped to where-object work in a script function when the same thing is known to work on command line?
Update
In addition to answer provided solutin was also able to use the following
function Get-Fnc {
$argsFncScope = $args # works because we make function scoped copy of args that flows down into Where-Object script block / stack frame
Write-Host "function scoped args assigned variable argsFncScope = $argsFncScope and count = $($argsFncScope.Count) and type = $($argsFncScope.GetType().BaseType)"
Get-ChildItem function:\ | Where-Object { $_.Name -like "$argsFncScope" }
}
Debug Output
get-fnc *-env
[DBG]: PS C:\Users\myusrn\Documents\WindowsPowerShell>
function scoped args assigned variable argsFncScope = *-env and count = 1 and type = array
[DBG]: PS C:\Users\myusrn\Documents\WindowsPowerShell>
CommandType Name Version Source
----------- ---- ------- ------
Function Get-Env
Each scriptblock has its own $args automatic variable.
function Get-Fnc {
Get-ChildItem function:\ | where-object { write-host $args;
$_.name -like "$args" } }
get-fnc get-*
# lots of empty lines
The $args for where-object is a $null array.
function Get-Fnc {
Get-ChildItem function:\ | where-object { $global:myargs = $args;
$_.name -like "$args" } }
get-fnc get-*
$myargs
$myargs.count
0
$myargs.gettype()
IsPublic IsSerial Name BaseType
-------- -------- ---- --------
True True Object[] System.Array
You can however use the other version of where-object that doesn't use a scriptblock:
function Get-Fnc {
Get-ChildItem function:\ | where-object name -like $args }
get-fnc get-*
CommandType Name Version Source
----------- ---- ------- ------
Function Get-Fnc
See also: Why doesn't PowerShell Where-Object work when passing a variable?
I actually don't know a way to set $args within the where-object scriptblock, but here's another example of a scriptblock and $args. $args is actually an array.
& { $args[0]; $args[1] } hi there
hi
there

Logging to console and file with function passing back return code

I've decided it makes sense that functions being called by a Powershell script should
Log the same output to both a log file and to the console and
should return a status indicating success/failure.
I found a way to do this but it seems ridiculously cumbersome and backwards (illustrated below). I'm thinking this is such a basic and essential capability for any scripting language and that I must be really lost and confused to be doing something in such a backwards way. I'm pretty new to PowerShell but come from a C# background.
I ended up adding -PassThru to every Add-Content statement in the function so the log entry will be coming back in the pipeline as item of an Object[] collection. I then am passing back a final boolean item in the Object[] collection which is the status of the function.
# Main script c:\temp\test1.ps1
Function Write-FunctionOutputToConsole {
Param ([Object[]] $FunctionResults)
foreach ($item in $FunctionResults) {
if ($item -is [System.Array]) {
Write-Host $($item)
}
}
}
Function Get-FunctionReturnCode {
Param ([Object[]] $FunctionResults)
if ($FunctionResults[-1] -is [System.Boolean]) {
Return $FunctionResults[-1]
}
}
. c:\temp\test2.ps1 #pull in external function
$LogFile = "c:\temp\test.log"
$results = FunctionThatDoesStuff -LogFile $LogFile -DesiredReturnValue $true
Write-FunctionOutputToConsole -FunctionResults $results
$FunctionReturnCode = Get-FunctionReturnCode -FunctionResults $results
Add-Content -Path $LogFile -Value "$(Get-Date -Format G) Logging in Main: returnValue=$FunctionReturnCode" -PassThru
# Do some logic based on $FunctionReturnCode
External function
# c:\temp\test2.ps1
function FunctionThatDoesStuff {
Param(
[string] $LogFile,
[bool] $DesiredReturnValue
)
Add-Content -Path $LogFile -Value "-----------------------------------------" -PassThru
Add-Content -Path $LogFile -Value "$(Get-Date -Format G) returnValue=$DesiredReturnValue" -PassThru
Add-Content -Path $LogFile -Value "$(Get-Date -Format G) line 1 being logged" -PassThru
Add-Content -Path $LogFile -Value "$(Get-Date -Format G) line 2 being logged" -PassThru
return $DesiredReturnValue
}
Console Output:
PS C:\Temp> c:\temp\test1.ps1
-----------------------------------------
7/19/2018 3:26:28 PM returnValue=True
7/19/2018 3:26:28 PM line 1 being logged
7/19/2018 3:26:28 PM line 2 being logged
7/19/2018 3:26:28 PM Logging in Main: returnValue=True
Log File
PS C:\Temp> get-content c:\temp\test.log
-----------------------------------------
7/19/2018 3:29:59 PM returnValue=True
7/19/2018 3:29:59 PM line 1 being logged
7/19/2018 3:29:59 PM line 2 being logged
7/19/2018 3:29:59 PM Logging in Main: returnValue=True
As you can see this results in the identical information in the Console and logging file.
I think you're misunderstanding how PowerShell works. For one thing, the information whether or not the last command was successful is automatically stored in the automatic variable $?. In case of an error cmdlets will throw an exception that can be caught for error handling (see also). There is no need to signal success or error status with a return value. Also, PowerShell by default returns all uncaptured output from a function. The return keyword is just for control flow.
I would implement a logging function somewhat like this:
function Write-LogOutput {
[CmdletBinding()]
Param(
[Parameter(Position=0, Mandatory=$true, ValueFromPipeline=$true)]
[string[]]$Message,
[Parameter(Position=1, Mandatory=$false)]
[ValidateScript({Test-Path -LiteralPath $_ -IsValid})]
[string]$LogFile = '.\default.log',
[Parameter(Mandatory=$false)]
[switch]$Quiet,
[Parameter(Mandatory=$false)]
[switch]$PassThru
)
Process {
$Message | ForEach-Object {
$msg = "[{0:yyyy-MM-dd HH:mm:ss}]`t{1}" -f (Get-Date), $_
if (-not $Quiet.IsPresent) {
$msg | Out-Host
}
$msg
} | Add-Content $LogFile
if ($PassThru.IsPresent) {
$Message
}
}
}
and then use it like this:
function FunctionThatDoesStuff {
# ...
# something that should be logged, but not returned
'foo' | Write-LogOutput -LogFile 'C:\path\to\your.log'
# something that should be logged and returned by the function
'bar' | Write-LogOutput -LogFile 'C:\path\to\your.log' -PassThru
# something that should be returned, but not logged
'baz'
# ...
}
$result = FunctionThatDoesStuff
# Output:
# -------
# [2018-07-19 23:44:07] foo
# [2018-07-19 23:44:07] bar
$result
# Output:
# -------
# bar
# baz

Enable Silverlight Plugin (NPAPI) in Chrome using registry key fix

I have created a Powershell script to add the npapi and Silverlight* registry keys to enable Silverlight in Google Chrome. The Powershell script works fine and adds the two registry keys, however the Silverlight plugin is still disabled in Chrome and when I load any Silverlight based sites I get the “Install Silverlight” popup. I have restarted the machine and still the Silverlight plugin is disabled.
However, if I go into the registry and delete just the npapi and Silverlight* registry keys and re-create them (String value - REG_SZ), when I reload the page in Chrome, Silverlight is now enabled and the site loads perfectly. I don’t understand what’s going on.
The powershell script creates these keys but only when I delete them and re-create them manually do they take effect and the Silverlight plugin is enabled. Then if I go into chrome://plugins, Chrome reports that the Silverlight plugin is “Enabled by Enterprise policy”. I have also run the script on another machine and the exact same thing happens. Has anyone else experienced this and does anyone know the fix or what I am doing wrong?
Powershell Script used to create the npapi and Silverlight* registry keys:
function Create-Path {
[CmdletBinding()]
param (
[Parameter(ValueFromPipeline = $false, Mandatory = $true)]
[string]$Path
,
[Parameter(ValueFromPipeline = $true, Mandatory = $false)]
[switch]$OverwriteIfExists
)
process {
If(($OverwriteIfExists.IsPresent) -or (-not (Test-Path $Path))) {
New-Item $Path -Force | out-null
}
}
}
function Get-RegistryKeyWithValue {
[CmdletBinding()]
param (
[Parameter(ValueFromPipeline = $false, Mandatory = $true)]
[string]$Path
,
[Parameter(ValueFromPipeline = $true, Mandatory = $true)]
[string]$Value
)
process {
$properties = Get-Item $Path | select -ExpandProperty Property
$properties | %{
$property = Get-ItemProperty -Path $Path -Name $_
if ($property.$_ -eq $Value) {
write-output $property
}
}
}
}
function Get-NextKeyInPath {
[CmdletBinding()]
param (
[Parameter(ValueFromPipeline = $false, Mandatory = $true)]
[string]$Path
)
process {
try {
write-output ((Get-Item $Path -ErrorAction Stop | select -ExpandProperty Property | Measure-Object -Maximum).Maximum + 1) | out-string
} catch {
write-output "1"
}
}
}
function Create-ChromeEnabledPluginPolicy {
[CmdletBinding()]
param (
[Parameter(ValueFromPipeline = $true, Mandatory = $true)]
[string]$Value
)
begin {
$ChromePluginPolicyPath = "HKLM:\SOFTWARE\Policies\Google\Chrome\EnabledPlugins"
Create-Path $ChromePluginPolicyPath
}
process {
if (-not (Get-RegistryKeyWithValue -Path $ChromePluginPolicyPath -Value $Value)) {
$keyName = Get-NextKeyInPath -Path $ChromePluginPolicyPath
New-ItemProperty -path $ChromePluginPolicyPath -Name $keyName -Value $Value -PropertyType String
}
}
}
"npapi", "Silverlight*" | Create-ChromeEnabledPluginPolicy
The code:
process {
try {
write-output ((Get-Item $Path -ErrorAction Stop | select -ExpandProperty Property | Measure-Object -Maximum).Maximum + 1) | out-string
} catch {
write-output "1"
}
}
Seems to return something more than a single string.
Amending to the following resolves the issue:
process {
try {
[int]$i = ((Get-Item $Path -ErrorAction Stop | select -ExpandProperty Property | Measure-Object -Maximum).Maximum + 1)
write-output ([string]$i)
} catch {
write-output "1"
}
}
A simplified demo of the issue & solution:
Run the following code: New-ItemProperty -Path 'HKLM:\SOFTWARE\JohnLBevan' -Name (1 | out-string) -PropertyType String -Value 'test'
Now open regedit and create a key with name 1; it succeeds (i.e. you have two keys called 1; so clearly some control/non displayable character is being added in our PS script).
If you try to add a third key called 1 using either method (regedit or powershell) you'll get an error due to a key with that name already existing (showing that there is a unique check in place; it's just our original 1s aren't unique)
If you try either of the following code snippets, things work as expected:
New-ItemProperty -Path'HKLM:\SOFTWARE\JohnLBevan' -Name "1" -PropertyType String -Value 'test'
New-ItemProperty -Path'HKLM:\SOFTWARE\JohnLBevan' -Name [string]1 -PropertyType String -Value 'test'
(Disclosure: I work with #jwoods83, so had the advantage of seeing the issue / playing with it directly)

PowerShell: Function doesn't have proper return value

I wrote a powershell script to compare the content of two folders:
$Dir1 ="d:\TEMP\Dir1"
$Dir2 ="d:\TEMP\Dir2"
function Test-Diff($Dir1, $Dir2) {
$fileList1 = Get-ChildItem $Dir1 -Recurse | Where-Object {!$_.PsIsContainer} | Get-Item | Sort-Object -Property Name
$fileList2 = Get-ChildItem $Dir2 -Recurse | Where-Object {!$_.PsIsContainer} | Get-Item | Sort-Object -Property Name
if($fileList1.Count -ne $fileList2.Count) {
Write-Host "Following files are different:"
Compare-Object -ReferenceObject $fileList1 -DifferenceObject $fileList2 -Property Name -PassThru | Format-Table FullName
return $false
}
return $true
}
$i = Test-Diff $Dir1 $Dir2
if($i) {
Write-Output "Test OK"
} else {
Write-Host "Test FAILED" -BackgroundColor Red
}
If I set a break point on Compare-Object, and I run this command in console, I get the list of differences. If I run the whole script, I don't get any output. Why?
I'm working in PowerGUI Script Editor, but I tried the normal ps console too.
EDIT:
The problem is the check on the end of the script.
$i = Test-Diff $Dir1 $Dir2
if($i) {
Write-Output "Test OK"
...
If I call Test-Diff without $i = check, it works!
Test-Diff returns with an array of objects and not with an expected bool value:
[DBG]: PS D:\>> $i | ForEach-Object { $_.GetType() } | Format-Table -Property Name
Name
----
FormatStartData
GroupStartData
FormatEntryData
GroupEndData
FormatEndData
Boolean
If I comment out the line with Compare-Object, the return value is a boolean value, as expected.
The question is: why?
I've found the answer here: http://martinzugec.blogspot.hu/2008/08/returning-values-from-fuctions-in.html
Functions like this:
Function bar {
[System.Collections.ArrayList]$MyVariable = #()
$MyVariable.Add("a")
$MyVariable.Add("b")
Return $MyVariable
}
uses a PowerShell way of returning objects: #(0,1,"a","b") and not #("a","b")
To make this function work as expected, you will need to redirect output to null:
Function bar {
[System.Collections.ArrayList]$MyVariable = #()
$MyVariable.Add("a") | Out-Null
$MyVariable.Add("b") | Out-Null
Return $MyVariable
}
In our case, the function has to be refactored as suggested by Koliat.
An alternative to adding Out-Null after every command but the last is doing this:
$i = (Test-Diff $Dir1 $Dir2 | select -last 1)
PowerShell functions always return the result of all the commands executed in the function as an Object[] (unless you pipe the command to Out-Null or store the result in a variable), but the expression following the return statement is always the last one, and can be extracted with select -last 1.
I have modified the bit of your script, to make it run the way you want it. I'm not exactly sure you would want to compare files only by the .Count property though, but its not within the scope of this question. If that wasn't what you were looking after, please comment and I'll try to edit this answer. Basically from what I understand you wanted to run a condition check after the function, while it can be easily implemented inside the function.
$Dir1 ="C:\Dir1"
$Dir2 ="C:\Users\a.pawlak\Desktop\Dir2"
function Test-Diff($Dir1,$Dir2)
{
$fileList1 = Get-ChildItem $Dir1 -Recurse | Where-Object {!$_.PsIsContainer} | Get-Item | Sort-Object -Property Name
$fileList2 = Get-ChildItem $Dir2 -Recurse | Where-Object {!$_.PsIsContainer} | Get-Item | Sort-Object -Property Name
if ($fileList1.Count -ne $fileList2.Count)
{
Write-Host "Following files are different:"
Compare-Object -ReferenceObject $fileList1 -DifferenceObject $fileList2 -Property FullName -PassThru | Format-Table FullName
Write-Host "Test FAILED" -BackgroundColor Red
}
else
{
return $true
Write-Output "Test OK"
}
}
Test-Diff $Dir1 $Dir2
If there is anything unclear, let me know
AlexP