This document discusses PowerShell formatting and summarization techniques. It reviews default formatting, composite formatting strings, formatting with Format-Table and Format-List, and using formatting XML. It also demonstrates formatting strings, hash tables for formatting, and using a module called EasyOutput to simplify complex formatting tasks.

1. How Do They Do That?
Formatting with PowerShell
Thomas Lee

2. Agenda
• Review the basics
• Composite Formatting and .ToString
• Formatting with Format-tables
• Using Format XML
• EasyOutput (thanks James!)
• DEMOS!!

3. Who Am I
• Consultant/writer/trainer – living in the UK
• Long time PowerShell MVP
• 2 blogs
– http://tfl09.blogspot.com – Under The Stairs
– http://pshscripts.blogspot.com – PowerShell
Scripts Blog

4. Formatting by Default
• PowerShell formats output by default
– controlled by *.PS1XML files
– Some default rules if all else fails
• How Default Formatting Works
– Objects in the pipeline - send to Out-Default
– Out-Default looks at the objects in the pipeline
– If formatting instructions – send to Out-Host
– If objects - send to Format-List or Format-Table

5. Formatting Rules
• If format.ps1xml defines format for a type
– Use that
• If not, does type.ps1xml define a default
property set
– Use that and the rules below
• Otherwise table vs list rules
– 4 or less properties, output a table
– 5 or more output a list

6. Format-Table and Format-List
 Format-List/Format-Table take objects from
pipeline
 Formats those objects
 Default contents and ‘shape’ from .ps1xml
 You can override default properties
 GWMI win32_ComputerSystem | fl name,model
 Can also take a hash table for precise format
control

7. Occurrence Type Drives Formatting
• An object’s type determine how PowerShell
renders instances
• .PS1XML defines the format for many types
– Others use the last resort rules (1-4/5+)

8. Other Stuff I Assume You Know
• Format-Wide and what it’s good for
• The basic Format-Table and Format-List
cmdlets
• The –autosize parameter on Format-Table
– And the implications for larger result sets
• Out-GridView
• Other Output mechanisms (XML, CSV, etc.3)

9. Demo 1
REVIEWING THE BASICS

10. Formatting Strings
• You can use either
– -f operator, and format values into a composite
formatting string
“This is {0}, formatting with {1}” –f “fun” , ”PowerShell”
– Use .ToString() to format a single value

11. Composite Formatting String
• Format of anchor
– {<number, width:formatspecifier>}
– Eg {0, 10: n4}
• Formatting
<string with anchors> -f <array of values>
• Produces a formatted string of array values
• $date=get-date
• “Today, {0}, is {1}” –f $date.date, $date.dayofweek

12. .ToString()
 All base types have a .ToString() method
 Inherited from [Object]
 Relied on to convert the object to a printable form
 Can take parameters!
 Base types have power over how to format
 Pass format string in call to .ToString()
 $i = 23.123456; $i.tostring("N2")
 23.12

13. .NET Format String Reference
 Numeric format strings
 http://msdn.microsoft.com/en-
us/library/427bttx3(VS.71).aspx
 Date and time format strings
 http://msdn.microsoft.com/en-
us/library/97x6twsz(VS.71).aspx

14. Demo 2
FORMATTING STRINGS/.TOSTRING()

15. Formatting with Hash Tables
 Uses a Hash Table with pre-defined key
names:
 Name (or Label) - <string>
 Expression - <string> or <script block>
 FormatString - <string>
 Width - <int32>
 Alignment (value can be "Left", "Center", or "Right")
 Send FT/FL hash table vs a property name

16. Hash Table Example
$Pn=@{label="Process Name";
Expression={$_.Name};
Alignment="right"}
$Cpu=@{label="CPU Cost";
Expression={($_.CPU) * 21;.23};
FormatString=“C3"}
Get-Process notepad| Format-Table $Pn,$Cpu -auto

17. Demo 3
FORMAT-TABLE WITH HASH TABLES

18. Formatting and .PS1XML
 Two types of ps1xml
 Define/update types - *.types.ps1xml
 Define/update formatting - *.format.ps1xml
 Default Format XML shipped with PowerShell
 Apps or OS additions add to this default set
 Stored in $Pshome

19. Format driven by object's type
• Discover a variable’s type name(s)
– $variable.PSTYPENAMES
• To add a type name
– $variable.PSTYPENAMES.ADD(“new name”)
• To clear all type names
– $variable.PSTYPENAMES.CLEAR()

20. Formatting XML
 To change how PowerShell formats a type?
 Create XML file
 Define views: table, list , etc
 Run Update-FormatData to add new view
 Add this to $profile to persist the changes

21. XML – Overall Structure
 <Name>
 Identifies the name of the view.
 <ViewSelectedBy>
 Specifies the object type or types to which the
view applies.
 <GroupBy>
 Specifies how items in the view should be
combined in groups.
 <TableControl> <ListControl> <WideControl>
<ComplexControl>
 Contain the tags that specify how each item is
displayed.

22. Consider A New Type
Add-Type @'
public class aeroplane
{
public string Model = "Boeing 737";
public int InFleet = 12;
public int Range = 2400;
public int Pax = 135;
}
'@
 But what about the display?

23. XML File Structure
<?xml version="1.0" encoding="utf-8" ?>
<Configuration>
<ViewDefinitions>
<View>
<Name> … </Name>
<ViewSelectedBy> <TypeName> … </TypeName> </ViewSelectedBy>
<TableControl> … </TableControl>
<ListControl> … </ListControl>
</ViewDefinitions>
</Configuration>

24. TableControl Definition
<TableControl>
<TableHeaders>
<TableColumnHeader>
<label>Passengers Carried</label><width>20</width>
</TableColumnHeader> …
</TableHeaders>
<TableRowEntries>
<TableRowEntry>
<tableColumnItem><PropertyName>Pax</PropertyName></tablecolumnitem>
</TableRowEntry> …
</TableRowEntries>
</TableControl>

25. ListControl
<ListControl>
<ListEntries>
<ListEntry>
<ListItems>
<ListItem>
<PropertyName>Model</PropertyName>
</ListItem> …
<ListItems>
<ListEntry>
</ListEntries>
</Listcontrol>

26. Sticking It Together
 Author, then save XML
 Prior to use, update format data
Update-FormatData –Prepend <format file name>
• Consider this pattern of development
– PowerShell
– PowerShell
– Test stuff and find bugs
– Exit
– Edit the XML
– PowerShell
– Do it again

27. Demo 4
DISPLAY XML

28. But wait
 Building XML is hard, boring, and just plain
work
 Instead of DIY
 Easy out
 Great add on module

29. Demo 5
EASY OUT

30. Summary
 Formatting can be simple or complex
 Lots of alternatives – have it your way
 Keep it simple and extend to meet your needs
 Use EZ-out if you are accessing obscure WMI
classes or using uncommon .NET types
• Demo 5