New PowerShell cmdlets in Windows Server 2016 TP2 (compared to Windows Server 2012 R2)

1. State the problem

With the release of Windows Server 2016 TP2 a few weeks ago, I was wondering what new PowerShell cmdlets are now included (when you compare to Windows Server 2012 R2). However, the list of cmdlets is so long now that it is hard to spot the differences by hand.

However, there a cmdlet in PowerShell to show all the cmdlets available (Get-Command) and a little bit of programming would make it easy to find out what are the main differences. So I set out to collect the data and compare the list.

DISCLAIMER: As you probably know already, the Technical Preview is subject to change so all the information about Windows Server 2016 TP2 is preliminary and may not make it into the final product. Use with care, your mileage may vary, not available in all areas, some restrictions apply, professional PowerShell operator on a closed Azure VM course, do not attempt.

2. Gather the data

First, I needed the list of cmdlets from both versions of the operating system. That was actually pretty easy to gather, with a little help from Azure. I basically provisioned two Azure VM, one running Windows Server 2012 R2 and one running Windows Server 2016 Technical Preview 2 (yes, TP2 is now available in the regular Azure VM image gallery).

Second, I installed all of the Remote Server Administration Tools (RSAT) on both versions. That loads the PowerShell modules used for managing features that are not installed by default, like Failover Cluster or Storage Replica.

Finally, I ran a simple cmdlet to gather the list from Get-Command and save it to an XML file. This made it easier to put all the data I needed in a single place (my desktop machine running Windows 10 Insider Preview). Here's a summary of what it took:

• Create WS 2012 R2 Azure VM
• Install RSAT in the WS 2012 R2 VM
  • Get-WindowsFeature RSAT* | Install-WindowsFeature
• Capture XML file with all the WS 2012 R2 cmdlet information
  • Get-Command | Select * | Export-CliXml C:\WS2012R2Cmdlets.XML
• Create WS 2016 TP2 Azure VM
• Install RSAT in the WS 2016 TP2 VM
  • Get-WindowsFeature RSAT* | Install-WindowsFeature

• Capture XML file with all the WS 2016 TP2 cmdlet information
  • Get-Command | Select * | Export-CliXml C:\WS2016TP2Cmdlets.XML

3. Process the data

With the two XML files at hand, all I had left to do was to compare them to produce a good list of what's new. The first attempt resulted in a long list that was hard to understand, so I decided to do it module by module.

The code starts by creating a combined list of modules from both operating systems. Then it builds a dictionary of all cmdlets for a given module, assigning the value 1 if it's in WS 2012 R2, 2 if it's in WS 2016 TP2 and 3 if it's in both.

Then I would show the total number of cmdlets per module per OS, then number of new cmdlets and the actual list of new cmdlets. Since the goal was to publish this blog, I actually wrote the script to format the output as an HTML table. Quite handy :-).

4. Show the results

Finally, here is resulting table with all the new PowerShell cmdlets (by module) in Windows Server 2016 TP2, compared to Windows Server 2012. Enjoy!

5. Share the code

For those wondering about the script I used to compile the results, here it goes.

#
# Enumerating all the modules from both OS versions
#

$Files= ( (Import-Clixml"C:\WS2012R2Cmdlets.XML"),
           (Import-Clixml"C:\WS2016TP2Cmdlets.XML") )
$ModuleDict= @{}

$Files|% {
  $_|GroupModuleName|SortName|% {
    $Module=$_.Name
    If ($ModuleDict.ContainsKey($Module)) {
      $ModuleDict.$Module++
    } Else {
      $ModuleDict.Add($Module,1)
    } # End If
  } # End Import
} # End 0..1

#
# Enumerate the cmdlets in every module
#

Write-Host"<table border=1><tr><td><b>Module</b></td><td>New Cmdlets</td><td>WS 2016 TP2</td><td>WS 2012 R2</td></tr>"
$ModuleDict.GetEnumerator() |SortName|% {
  $Module=$_.Name
  $VersionCount= (0,0)
  $CmdletDict= @{}

  0..1|% {
    $WSVersion=$_
    $Files[$_]|?ModuleName-eq$Module|% {
      $Cmdlet=$_.Name
      $VersionCount[$WSVersion]++
      If ($CmdletDict.ContainsKey($Cmdlet)) {
        $CmdletDict.$Cmdlet+= ($WSVersion+1)
      } Else {
        $CmdletDict.Add($Cmdlet, ($WSVersion+1))
      } # End If
    } # End %
  } # End 0..1

  #
  # Output the list of cmdlets that changed in every module
  #

  $WS0=$VersionCount[0]
  $WS1=$VersionCount[1]
  $Dif=$WS1-$WS0
  $CrLf="<BR>"+[char]10+[char]13

  Write-Host"<tr><td><b>$Module</b></td><td align=`"right`">$Dif</td><td align=`"right`">$WS1</td><td align=`"right`">$WS0</td></tr>"
  If ($CmdletDict.Count -gt0) {
    $CmdletList=""
    $CmdletDict.GetEnumerator() |? {$_.Value -eq2-or$_.Value -eq1} |SortName|% {
      $Name=$_.Name
      If ($_.Value -eq1) {
        $CmdletList+="- $Name"+$CrLf
      } else {
        $CmdletList+="+ $Name"+$CrLf
      } # End If
    } # End Enumerator
    If ($CmdletList-ne"") {
      Write-Host"<tr><td colspan=4>$CmdletList</td></tr>"
    } # End If
  } # End if

} # End Module
Write-Host"</table>"