I want to be able to do this with my own functions, but as far as I can tell, there is no built-in mechanism for this for using an specified parameter instead of the pipe.

[Updated]

What I do is this:

# A simple function that multiplies input items by 3
function times3 {
  param($i)
  # this inner function does the actual processing
  function proc($o) {
      $o * 3
  }
  # if -i supplied used instead of std $input
  if ($i) { $input = $i }
  foreach ($o in $input) {
    proc $o
  }
}

Normally, you’d use a function with a process block to process each object ($_) in the pipeline, but in this case, I iterate over the pipeline’s $input manually. If the -i is supplied, $input is replaced with its value.

If I run this sequence:

$debugpreference="Continue"
write-debug "----------- about to call as function"
times3

write-debug "----------- about to pipe 4 numbers in to function"
1..4 | times3

write-debug "----------- about to call as function with -i"
times3 -i (1..4)

I get this:

PS Documents\\proj\\ps1> ./pipeornot.ps1
DEBUG: ----------- about to call as function
DEBUG: ----------- about to pipe 4 numbers in to function
3
6
9
12
DEBUG: ----------- about to call as function with -in
3
6
9
12
PS Documents\\proj\\ps1> get-bufferhtml > out.html

It would be nice if the the manual condition could be avoided by specifying

param($i=$input)

but sadly, this does not work.

Maybe in the next version of PowerShell, or perhaps there will be a more specific way of dealing with pipe or no pipe.

Additionally, I really like the way that hashes behave like objects with named properties. For example:

$a=@{"name"="bob";"age"=42}
$a.name # outputs "bob"
$a.age # outputs 42

Unfortunately, if you have a list/array of hashes with the same keys, you cannot benefit from this built-in formatting. The output comes out in two columns, keyed Name and Value.

I want a way to have the properties of the hash be the keys and the values be the values associated with those keys.

Consider the array of hashes created by this code:

$rnd = new-object Random
$list = @()
1..5 | % {
  $o = @{}
  "keyone","keytwo" | % {
    $o["$_"] = "x$($rnd.next(100))"
  }
  $list += $o
}

This creates an array of five hashes, each with two keys (keyone and keytwo) with random values.

If we type $list in the console, we get something like this:

Name                           Value
----                           -----
keyone                         x11
keytwo                         x33
keyone                         x47
keytwo                         x47
keyone                         x72
keytwo                         x57
keyone                         x85
keytwo                         x9
keyone                         x43
keytwo                         x35

This is not what I want. I want the columns to be keyone and keytwo with the values below.

One way around this is to do something like this (all on one line):

$list | select-object @{Name="keyone";Expression={$_.keyone}},@{Name="keytwo";Expression={$_.keytwo}}

Behold! we get what I want:

keyone                                                      keytwo
------                                                      ------
x72                                                         x71
x18                                                         x6
x59                                                         x60
x37                                                         x39
x63                                                         x10

Unfortunately, this requires me to know which columns I want in advance, and with more than two columns, it gets rather verbose.

A solution, that works well for me, is to write a function that replaces hashes in the pipe with a custom PowerShell object with added properties… the cmdlet add-member comes the rescue:

function convertto-hashobject {
  process {
    if ($_ -is [Collections.IDictionary]) {
      $hash = $_
      $out = new-object object
      foreach ($k in $hash.Keys) {
        $out = add-member -i $out -type "noteproperty" -name "$k" -force -passthru $hash[$k]
      }
      $out
    }
    else {
      $_
    }
  }
}

Now, regardless of the hash contents, we can do this:

$list | convertto-hashobject 

to get this:

keyone                                                      keytwo
------                                                      ------
x72                                                         x71
x18                                                         x6
x59                                                         x60
x37                                                         x39
x63                                                         x10

Now, this post is tagged as a Quiz, because I’m sure there is a better way of doing this. Perhaps something blindingly obvious that I missed, or something really cunning.

Let me know!

1. Simple and most boring: use the internal speaker’s beep.

write-host "`a`a`a"

2. Slightly better, use the .NET console beep. This plays A above middle C for one second.

[console]::beep(440,1000)

Both of the above are synchronous, ie, the script blocks until the sound has finished. Richy Rich is doing some interesting stuff with runspaces to do this asynchronously.

3. Lastly, you can play wav files. Sadly, only .wav files. No midi, mp3, mpeg4.. at least I couldn’t find anything in .net 2.

$file='C:\\WINDOWS\\Media\\Windows XP Startup.wav'
$sp = new-object Media.SoundPlayer ($file)
$sp.Load();
$sp.Play();
1..5 | % {
  echo "la la"
  sleep 1
}

This plays the wav asynchronously, so I feel should be used in a future version of psinvaders to get those authentic sounds.

So anyone know of a way to play midi files asynchronously in PowerShell with only a few lines of code?