Media And Microcode : System.Collections.Hashtable

Microcode: PowerShell Scripting Tricks: More Joy of Hashtables (with Get-HashtableAsObject)

JamesBrundage — Sun, 30 Nov 2008 05:10:27 GMT

I recently did two different "in depth" posts. One on The Joy Of Hashtables and another on Select-Object versus Add-Member. At the end of Select-Object vs Add-Member, I hinted at more convenient ways to write objects that used Script Properties. Script Properties are particularly useful because, unlike Note Properties, they are evaluated when they are requested. This means that PowerShell scripts that use script properties will often be faster than those using note properties. Sadly, they're kind of clunky to add. A script property will normally look like:

New-Object Object | Add-Member ScriptProperty Foo { Get-Random } -passThru

This gets pretty ugly, pretty fast.

Luckily, the post on hashtables gives us a good way out of this problem. Hashtables look fairly clean in PowerShell scripts, and, with a little bit of work, you can easily turn a hashtable into an object. Here's the Get-HashtableAsObject function.

In case you're curious, the comments inside of the function aren't just there for fun. They're an example of script-embedded help (which will not be out until CTP3). Once script-embedded Help is there, you can write help content for a function with just what's in the function below, and you'll be able to Get-Help on your function just like any other command.

function Get-HashtableAsObject([Hashtable]$hashtable) { #.Synopsis # Turns a Hashtable into a PowerShell object #.Description # Creates a new object from a hashtable. #.Example # # Creates a new object with a property foo and the value bar # Get-HashtableAsObject @{"Foo"="Bar"} #.Example # # Creates a new object with a property Random and a value # # that is generated each time the property is retreived # Get-HashtableAsObject @{"Random" = { Get-Random }} #.Example # # Creates a new object from a hashtable with nested hashtables # Get-HashtableAsObject @{"Foo" = @{"Random" = {Get-Random}}} process { $outputObject = New-Object Object if ($hashtable -and $hashtable.Count) { $hashtable.GetEnumerator() | Foreach-Object { if ($_.Value -is [ScriptBlock]) { $outputObject = $outputObject | Add-Member ScriptProperty $_.Key $_.Value -passThru } else { if ($_.Value -is [Hashtable]) { $outputObject = $outputObject | Add-Member NoteProperty $_.Key (Get-HashtableAsObject $_.Value) -passThru } else { $outputObject = $outputObject | Add-Member NoteProperty $_.Key $_.Value -passThru } } } } $outputObject } }

Let's check out a few practical examples of Get-HashtableAsObject:

Check out how we can use Get-HashtableAsObject to create a random card

$card = Get-HashtableAsObject @{ Card = {2..9 + "Jack", "Queen", "King", "Ace" | Get-Random} Suit = {"Clubs", "Hearts", "Diamonds", "Spades" | Get-Random} } $card $card $card

Notice that each time I output $card, the Card and Suit change. This is because the script property is being evaluated each time it is read. Essentially, it's shuffling every card. Cool, right?

The last post introduced you to PowerShell's ability to add hashtables together to merge them. Check out how we can use this to combine an object that generates user information and an object that generates system information.

$userInfo = @{ LocalUsers = {Get-WmiObject "Win32_UserAccount WHERE LocalAccount='True'"} LoggedOnUsers = {Get-WmiObject "Win32_LoggedOnUser" } } $systemInfo = @{ Memory = {Get-WmiObject Win32_PhysicalMemory} Drives = {Get-WmiObject Win32_LogicalDisk} } $liveUserInfo = Get-HashtableAsObject $userInfo $liveSystemInfo = Get-HashtableAsObject $systemInfo $allInfo = Get-HashtableAsObject ($userInfo + $systemInfo) $liveUserInfo.LocalUsers $allInfo.Drives

This trick is particularly convenient for quickly joining together chunks of logic from different scripts. For instance, if I wanted to add a property the $userInfo object that kicked off all users who had been logged on for over a period of time, I'd simply add another hashtable to the user info to accomplish this task. For those much more in tune with object-oriented programming, what this essentially gives me is the ability to inherit from an objects defined this way in PowerShell, without the joy of overloading. Faking overloading is considerably more complicated, so we'll save that one for another day, but I hope that the tricks contained within this post help you write more robust scripts.

Hope this helps,

James Brundage [MSFT]

Microcode: PowerShell Scripting Tricks: The Joy of using Hashtables with Windows PowerShell

JamesBrundage — Thu, 27 Nov 2008 10:01:14 GMT

PowerShell is full of nice little touches. While some of these touches are easy to run across, like Get-Command and Get-Help, there are also a lot of little ones that are very small changes that make working with some parts of PowerShell (and .NET) a whole lot easier. One area that's got a lot of little goodness, but that probably isn't as well-known, is the joy of using a Hashtable in PowerShell.

For the uninitiated, you can create an instance of System.Collections.Hashtable in Windows PowerShell by the simple shorthand @{Key=Value}. This offers a way you can express rather complicated data in a PowerShell script while keeping clean looking scripts. For instance, here's how some moderately complex personal information might look as a hashtable.

$person = @{
    First = "James"
    Last = "Brundage"
    Address = @{
        City = "Seattle"
        State = "Washington"
        Zip = 98102
        Street = "0 Way I Am Putting This On a Blog" 
    }
    Occupation = @{
        Industry = "Information Technology"
        Title="Software Developer In Test"
        Company="Microsoft Corporation"
    }
}

Now that we've covered the basics, lets get to the cool tricks.

Did you know? in PowerShell + adds Hashtables together.

Watch how you use this on $person to make a new key:

$person+=@{"FullName" = "$($person.First) $($person.Last)"}

Nifty, right?

Did you know? You can use the . operator to get or set a Hashtable entry.

$person.FullName

Since you can peek at values with a ., you can do a quick check to fill in information that might be missing from the hashtable.

Check out how to fill in the missing information from John Doe

$otherPerson = @{
    First = "John"
    Last = "Doe"    
}

$people = $person, $otherPerson

$people = $people | Foreach-Object {
    $p = $_ + @{"FullName" = "$($_.First) $($_.Last)"}    
    if (-not $p.Address) {
        $p.Address = "Unknown"
    }
    if (-not $p.Occupation) {
        $p.Occupation = "Unknown"
    }
    $p
}
$people

You can also access nested hashtables this way, which lets you group complex data.

Watch how to use this to create a new variable, $westCoastPeople:

$westCoastPeople = $people |
    Where-Object {"Washington", "Alaska", "Hawaii", "Oregon", "California" -contains $_.Address.State }

You can also use Group-Object to group by different properties.

$people | Group-Object {$_.Address.City, $_.Address.State}

If you need to walk through each item in a hashtable, then you can use .GetEnumerator() to walk the entries.

$person.GetEnumerator() | Foreach-Object {    
    $_.Key
    "-"
    $_.Value | Out-String
}

You can't remove an item while you're enumerating it, but by wrapping the enumerator in @(), you actually get a snapshot of collection and then you're free to modify it as you see fit.

Check out how you can use this to clear out any field that has "Unknown" in it.

$people | Foreach-Object {
    $p = $_
    @($p.GetEnumerator()) | Where-Object {            
        ($_.Value | Out-String) -like "*Unknown*"
    } | Foreach-Object {
        $p.Remove($_.Key)
    }
}

$people

As you can see, several nooks and crannies of how PowerShell works with .NET are quite useful, and make working with some objects in PowerShell incredibly nice. I hope you've had some fun with hashtables, and I hope I can shed some more light on fun with different .NET types in the future.

Hope this helps,

James Brundage [MSFT]