An example JSON string

The basic types are objects, lists, strings, numbers, and nulls. All of the keys in an object must be strings.

$json = @"
{
 "name": "John",
 "places_worked": ["New York", "Boston", "California"],
 "pet": null,
 "family": [{"name": "Eric", "age": 43, "pet": "Rosco"},
              {"name": "Dawn", "age": 47, "pet": "Rocky"}]
}
"@

PowerShell v3 Supports JSON

To convert a JSON string to a PowerShell object, use ConvertFrom-JSON. This PowerShell cmdlet is delivered out of the box with Version 3.

$json | ConvertFrom-Json            
            
name places_worked                  pet family                                                            
---- -------------                  --- ------                                                            
John {New York, Boston, California}     {@{name=Eric; age=43; pet=Rosco}, @{name=Dawn; age=47; pet=Rocky}}

Once converted, you can access individual properties of the PowerShell Object.

($json | ConvertFrom-Json).places_worked            
            
New York
Boston
California

Manually Converting the JSON to PowerShell

Starting with the original JSON example. I’ll remove it from the string and do several edits to make it valid PowerShell.

1. Adding an @ sign in from of the curly brackets makes it a hashtable
2. I cast the hashtable to a PowerShell object by using [PSCustomObject]
3. Replace the ‘:’ with ‘=’. Valid syntax for PowerShell hashtables
4. We’re building up a hashtable so, remove the ‘,’ or replace the with ‘;’
5. Change the ‘[]’ JSON array notation with ‘@()’ PowerShell array notation
6. Add a $ to null
7. Finally in the family property, I convert JSON Object notation to a PowerShell hashtable and cast it to an object with [PSCustomObject]

$list = [PSCustomObject]@{            
 "name" = "John"            
 "places_worked" = @("New York", "Boston", "California")            
 "pet" = $null            
 "family" = @([PSCustomObject]@{"name" = "Eric"; "age" = 43; "pet"= "Rosco"},            
              [PSCustomObject]@{"name" = "Dawn"; "age" = 47; "pet" = "Rocky"})            
}

Now we can access individual properties just like before.

$list.family

name age pet  
---- --- ---  
Eric  43 Rosco
Dawn  47 Rocky

Converting PowerShell Objects to JSON

Often coming form PowerShell or .NET we want take our objects and convert them to JSON strings so we can store them or send them over HTTP. PowerShell excels at this on many levels. Lets take our newly created list and use the building ConvertTo-JSON cmdlet to get a JSON string.

$list | ConvertTo-Json            
            
{
    "name":  "John",
    "places_worked":  [
                          "New York",
                          "Boston",
                          "California"
                      ],
    "pet":  null,
    "family":  [
                   {
                       "name":  "Eric",
                       "age":  43,
                       "pet":  "Rosco"
                   },
                   {
                       "name":  "Dawn",
                       "age":  47,
                       "pet":  "Rocky"
                   }
               ]
}

This string is ready to be sent over HTTP to an any endpoint that can handle JSON. See my other post Using PowerShell for dynamic JSON parsing.

Want more and Get 50% off?

My new book “PowerShell for Developers” covers these, other PowerShell v3 features and more. Use code DSUG for the discount.

• Slice and dice Text, XML, CSV, and JSON effortlessly
• Embed PowerShell to provide scripting abilities for your C# apps
• Create GUI applications five to ten times faster with less code
• Leverage PowerShell’s capabilities to work with the Internet
• Interact with DLLs and create objects, automatically display properties, and call methods in live interactive sessions
• Build domain-specific languages (DSLs) and vocabularies to express solutions more clearly
• Work with Microsoft Office via the Component Object Model (COM)
• Discover PowerShell v3 features included with Windows 8 and Windows Server 2012

Check out what else you can do in PowerShell v3 here and here.

Creating JSON on the fly with ConvertTo-JSON

Here is one simple way of creating JSON on the fly in PowerShell. I want to dial in on a couple of new PowerShell v3 features here.

First, I’m casting the hash table with [ordered] so the the keys will be in the order I add them.  Casting  to [ordered] creates an OrderedDictionary instead of HashTable.

Once I finish building up the ordered dictionary I pipe it to ConvertTo-Json, which, convers it to a JSON formatted string.

I need to set the depth to 3 with the –Depth parameter because the default is 2 levels of contained objects and my resulting structure has 3. The $jsonObject, $album and then $songs.

$jsonObject = [ordered]@{}            
            
$jsonObject.Entered = (Get-Date).DateTime            
            
$album = @{}            
$album.AlbumName = "Dirty Deeds Done Dirt Cheap"            
$album.Artist = "AC/DC"            
$album.YearReleased = 1976            
            
$album.Songs = @()            
                        
$song = @{}            
$song.SongName = "Dirty Deeds Done Dirt Cheap"            
$song.SongLength = "4:11"            
$album.Songs += $song            
            
$song = @{}            
$song.SongName = "Love at First Feel"            
$song.SongLength = "3:10"            
$album.Songs += $song            
            
$jsonObject.album = $album            
            
$jsonObject | ConvertTo-Json -Depth 3

Here is the resulting JSON.

{
"Entered":  "Saturday, September 01, 2012 10:30:04 AM",
"album":  
    {
        "Artist":  "AC/DC",
        "AlbumName":  "Dirty Deeds Done Dirt Cheap",
        "Songs":  [
                    {
                        "SongName":  "Dirty Deeds Done Dirt Cheap",
                        "SongLength":  "4:11"
                    },
                    {
                        "SongName":  "Love at First Feel",
                        "SongLength":  "3:10"
                    }
                ],
        "YearReleased":  1976
    }
}

Creating a PowerShell Object from JSON with ConvertFrom-JSON

Going the other way, this PowerShell snippet sets up a JSON string with three properties: Name, Company and Entered. Piping the string to ConvertFrom-Json creates a PowerShell object with these three properties.

$jsonString = @'
{
    "Name":"John",
    "Company":"Microsoft",
    "Entered":"2012-03-16T00:03:33.245-10:00"
}
'@            
            
$jsonString | ConvertFrom-Json

The resulting PowerShell object displayed.

Name Company   Entered                      
---- -------   -------                      
John Microsoft 2012-03-16T00:03:33.245-10:00

Complex JSON

Let’s take a look at a chewier JSON structure (see below the JSON string). From the string you can directly navigate to the objects, properties and elements of the arrays.

Notice here I’m using the new PowerShell v3 Member Enumeration feature. That’s why the two dates, 1976 and 1992 are printed from the single line $albums.YearReleased.

$albums = $jsonString | ConvertFrom-Json             
            
$albums.YearReleased            
            
$albums[0].AlbumName            
$albums[0].Songs[1].SongName

Result navigating Complex JSON

Here is what you get from running the previous script.

1976
1992
Dirty Deeds Done Dirt Cheap
Love at First Feel

JSON String

This is the JSON string used in the previous example.

$jsonString = [
{
"Id": "b3ec4e5c",
"AlbumName": "Dirty Deeds Done Dirt Cheap",
"Artist": "AC/DC",
"YearReleased": 1976,
"Entered": "2012-03-16T00:13:12.2810521-10:00",
"AlbumImageUrl": "http://ecx.images-amazon.com/images/I/61kTaH-uZBL._AA115_.jpg",
"AmazonUrl": "http://www.amazon.com/gp/product/…ASIN=B00008BXJ4",
"Songs": [
    {
    "AlbumId": "b3ec4e5c",
    "SongName": "Dirty Deeds Done Dirt Cheap",
    "SongLength": "4:11"
    },
    {
    "AlbumId": "b3ec4e5c",
    "SongName": "Love at First Feel",
    "SongLength": "3:10"
    },
    {
    "AlbumId": "b3ec4e5c",
    "SongName": "Big Balls",
    "SongLength": "2:38"
    }
]
},
{
"Id": "7b919432",
"AlbumName": "End of the Silence",
"Artist": "Henry Rollins Band",
"YearReleased": 1992,
"Entered": "2012-03-16T00:13:12.2800521-10:00",
"AlbumImageUrl": "http://ecx.images-amazon.com/images/I/51FO3rb1tuL._SL160_AA160_.jpg",
"AmazonUrl": "http://www.amazon.com/End-Silence-Rollins-Band/dp/B0000040OX/ref=sr_1_5?ie=UTF8&qid=1302232195&sr=8-5",
"Songs": [
    {
    "AlbumId": "7b919432",
    "SongName": "Low Self Opinion",
    "SongLength": "5:24"
    },
    {
    "AlbumId": "7b919432",
    "SongName": "Grip",
    "SongLength": "4:51"
    }
]
}]

Let’s Put some JSON on a Web endpoint

Using Invoke-RestMethod you can send PowerShell objects that have been converted to JSON to a web endpoint. I’m using the freely hosted HTTP Request & Response Service, http://httpbin.org.

I get the first two processes from Get-Process and convert them to JSON.  Then I add that JSON result to the overall payload and finally call Invoke-RestMethod which “puts” it to the web endpoint.

$p = Get-Process | Select -First 2 Name, Company, PM |             
        ConvertTo-Json            
            
$jsonString = "[{Date=$(Get-Date), Processes=$($p)}]"            
            
$body = $jsonString | ConvertTo-Json            
            
Invoke-RestMethod -Method Put http://httpbin.org/put -Body $body

Web Endpoint Results

We can see from the json properties that the values were transmitted correctly.

origin  : 68.174.133.109
files   : 
form    : 
url     : http://httpbin.org/put
args    : 
headers : @{Content-Length=302; Host=httpbin.org; Content-Type=; Connection=keep-alive; User-Agent=Mozilla/5.0 (Windows NT; Windows NT 6.1; en-US) 
          WindowsPowerShell/3.0}
json    : [{Date=09/02/2012 15:23:26, Processes=[
              {
                  "Name":  "armsvc",
                  "Company":  "Adobe Systems Incorporated",
                  "PM":  1249280
              },
              {
                  "Name":  "atieclxx",
                  "Company":  "AMD",
                  "PM":  2473984
              }
          ]}]
data    : "[{Date=09/02/2012 15:23:26, Processes=[\r\n    {\r\n        \"Name\":  \"armsvc\",\r\n        \"Company\":  \"Adobe Systems 
          Incorporated\",\r\n        \"PM\":  1249280\r\n    },\r\n    {\r\n        \"Name\":  \"atieclxx\",\r\n        \"Company\":  \"AMD\",\r\n       
           \"PM\":  2473984\r\n    }\r\n]}]"

Using JSON.net to consume the JSON Stack Overflow API – Jonathan Creamer takes a look at consuming JSON powered APIs using .NET code, looking at the JSON.NET library as probably the best way of consuming such data, and exploring its use consuming the StackOverflow API.

PowerShell v3 Solution

It’s worth comparing the number of lines it takes to get this done in C# vs. PowerShell. Put another way, Ceremony vs. Essence. Plus, this script is a one to one mapping to the C# done by Jonathan. I’m seamlessly integrating PowerShell with the .NET Framework. The only difference is I use the PowerShell Cmdlet ConvertFrom-Json. That does all the heavy lifting, converting the JSON to PowerShell objects with properties. No need to download a 3rd party DLL like JSON.net. Check out the results below.

function Get-StackOverflowUser ($id="110865") {            
               
    $url = "http://api.stackoverflow.com/1.1/users/$id"            
    $data = (New-Object Net.WebClient).DownloadData($url)            
    $memoryStream = New-Object System.IO.MemoryStream(,$data)            
    $decompress = New-Object `
        System.IO.Compression.GZipStream($memoryStream,"Decompress")            
    $reader = New-Object System.IO.StreamReader($decompress)            
    $ret = $reader.ReadToEnd()            
            
    ($ret | ConvertFrom-Json).Users            
}            
            
Get-StackOverflowUser 110865

Results

user_id             : 110865
user_type           : registered
creation_date       : 1242960794
display_name        : Doug Finke
reputation          : 1666
email_hash          : 94c48c63e7e63f5e713f7f7a5cdbcac0
last_access_date    : 1328745843
website_url         : http://dougfinke.com/blog/
location            : New York, NY
about_me            : Software Developer and Microsoft PowerShell MVP
question_count      : 7
answer_count        : 72
view_count          : 70
up_vote_count       : 72
down_vote_count     : 2
accept_rate         : 71
user_questions_url  : /users/110865/questions
user_answers_url    : /users/110865/answers
user_favorites_url  : /users/110865/favorites
user_tags_url       : /users/110865/tags
user_badges_url     : /users/110865/badges
user_timeline_url   : /users/110865/timeline
user_mentioned_url  : /users/110865/mentioned
user_comments_url   : /users/110865/comments
user_reputation_url : /users/110865/reputation
badge_counts        : @{gold=0; silver=3; bronze=9}

Summary

If you’re running Windows 7, you can download PowerShell v3 CTP2 HERE. I hear the Windows 8 Consumer Preview could  launch February 29. Windows 8 comes with PowerShell v3 and both are pretty slick.

Well, back to writing another chapter in my PowerShell book, “Building GUIs in PowerShell”.

After requesting API Key from the New York Times, I worked up this reusable query in PowerShell. Time for more exploration.

Note: This PowerShell code only works on Version 3. I am using the new cmdlet Invoke-RestMethod and the simplified Where syntax.

Get-SemanticNYT "obama" |            
    Get-SemanticNYTArticles |             
    where links |             
        select -ExpandProperty article_list |             
        select -ExpandProperty results |             
        select Title, Date, Body | Out-GridView

Injecting a GUI into the Command Line

Out-GridView is one of the cmdlets delivered with PowerShell.

PowerShell Code

PowerShell’s parameter binding saves time and effort. Specifying ValueFromPipelineByPropertyName, lets me quickly pipe results from one Web API to the other. Letting PowerShell do the work of binding the output from one function to the other. This lets me focus on problem solving.

Invoke-RestMethod does all the heavy lifting when interacting with the Web, (Invoke-RestMethod $uri).results:

• Hits the endpoint
• Retrieves the JSON
• Converts the JSON to PowerShell objects 

function Get-SemanticNYT {            
                
    param($query = "obama")            
            
    $uri = "http://api.nytimes.com/svc/semantic/v2/"+            
        "concept/search.json?query=$query&api-key=$apiKey"            
            
    (Invoke-RestMethod $uri).results            
}            
            
function Get-SemanticNYTArticles {            
                
    param(            
        [Parameter(ValueFromPipelineByPropertyName)]            
        $concept_name,            
        [Parameter(ValueFromPipelineByPropertyName)]            
        $concept_type            
    )            
            
    process {            
      $uri = "http://api.nytimes.com/svc/semantic/v2/" +            
      "concept/name/$concept_type/$concept_name.json?&" +            
      "fields=all&api-key=$apiKey"            
            
      (Invoke-RestMethod $uri).results            
    }            
}

Great feedback from the PowerShell community. I now use [Math]::Floor to avoid an error in rounding, if I use [int] it rounds up. Plus I de-pluralized the names of the functions. Thanks Chris and Aleksandar.

This script lets you see your Twitter followers name, screen name and location. Using the new Invoke-RestMethod in PowerShell Version 3, it retrieves and converts the JSON to make it easily accessible in PowerShell.

Get-TwitterFollower dfinke | Out-GridView

The Code

function Get-TwitterFollower ($screenName) {                        
            
    $baseUrl = "https://api.twitter.com/1"            
    function Get-Follower ($userIds) {            
        $userIds = @($userIds) -join ","            
        $url = "$baseUrl/users/lookup.json?user_id=$($userIds)&include_entities=true"            
        (Invoke-RestMethod $url) |            
            select  name, screen_name, location            
    }                                    
            
    $url = "$baseUrl/followers/ids.json?cursor=-1&screen_name=$($screenName)"            
    $followers = (Invoke-RestMethod $url).ids                                     
            
    $blocks   = [Math]::Floor($followers.Count / 100)            
    $leftover = $followers.Count % 100                                    
            
    for($idx=0; $idx -lt $blocks; $idx+=1) {                    
        Get-Follower ($followers | select -First 100 -skip ($idx*100))            
    }            
                
    Get-Follower ($followers | select -First $leftOver -skip ($idx*100))            
}

This example takes a CSV string, converts it, using ConvertFrom-Csv,  into PowerShell objects with the properties Name and Age and then converts it to JSON using ConvertTo-JSON. The csv data could have been pulled from a file using Import-CSV.

The JSON can then be used in a post to a web service using PowerShell’s Invoke-RestMethod –Method Post.

@"
Name, Age
John Doe, 10
Tom Doe, 20
Jane Doe, 30
Harry Doe, 40
"@ | ConvertFrom-Csv | ConvertTo-Json            
            
            
# Results             
@"
{
    "Name":  "John Doe",
    "Age":  "10"
}
{
    "Name":  "Tom Doe",
    "Age":  "20"
}
{
    "Name":  "Dick Doe",
    "Age":  "30"
}
{
    "Name":  "Harry Doe",
    "Age":  "40"
}
"@

This week Microsoft released the Windows Developer Preview and PowerShell V3 was also delivered. Two of the new commands included, ConvertTo-JSON and ConvertFrom-JSON.

I had fun building these scripts. From it I learned that PowerShell didn’t support Tail Call Optimization and ended up using the Trampoline Method. Those were my early days working with PowerShell. We’ve both survived and come along way and are much stronger for it.

I’m looking forward to V3 being fully baked and released with Windows 8 and Windows 8 Server.

Here is my original post Implementing a JSON parser.

These are the examples I put on the CodePlex page and the work verbatim with V3.

PS C:\> '[{"title":"PowerShell"},{"title":"Test"}]' | ConvertFrom-JSON

title
-----
PowerShell
Test

(New-Object PSObject |
   Add-Member -PassThru NoteProperty Name 'John Doe' |
   Add-Member -PassThru NoteProperty Age 10          |
   Add-Member -PassThru NoteProperty Amount 10.1     |
   Add-Member -PassThru NoteProperty MixedItems (1,2,3,"a") |
   Add-Member -PassThru NoteProperty NumericItems (1,2,3) |
   Add-Member -PassThru NoteProperty StringItems ("a","b","c")
) | ConvertTo-JSON

{
    "Name":  "John Doe",
    "Age":  10,
    "Amount":  10.1,
    "MixedItems":  [
                       1,
                       2,
                       3,
                       "a"
                   ],
    "NumericItems":  [
                         1,
                         2,
                         3
                     ],
    "StringItems":  [
                        "a",
                        "b",
                        "c"
                    ]
}

If you care at all about how data is accessed–and you should–understanding the basics of OData is probably worth your time.

Dave Chappell’s post, Introducing OData, does a great job walking through what OData is. Covering REST, Atom/AtomPub, JSON, OData filter query syntax, mobile devices, the Cloud and more.

Our world is awash in data. Vast amounts exist today, and more is created every year. Yet data has value only if it can be used, and it can be used only if it can be accessed by applications and the people who use them.
Allowing this kind of broad access to data is the goal of the Open Data Protocol, commonly called just OData. This paper provides an introduction to OData, describing what it is and how it can be applied.

OData PowerShell Explorer

I open sourced an OData PowerShell Explorer complete with a WPF GUI using WPK. The PowerShell module allows you to discover and drill down through OData services using either the command line or the GUI interface.

Other Resources

• OData Primer
• RunAs Radio podcast on the OData PowerShell Explorer
• Open Data Protocol
• Download TechEd Sessions Automatically by Using PowerShell

I added ConvertTo-JSON which takes a PowerShell Object and generates a JSON string.

Very handy.

PowerBoots makes him really really want to move to PowerShell. PowerBoots makes it easy to create GUIs in PowerShell on top of WPF.

Here are some posts on Boots and PowerShell

• JSON, XAML, PowerBoots and PowerShell

• PowerShell, PowerBoots and an Oslo DSL Grammar

• PowerShell Picture Viewer using WPF with PowerBoots

• PowerShell meet WPF via PowerBoots