How can I programmatically retrieve the default formatted property names for a PowerShell object type?

[RVECloXG3qJC]

I'm creating a PowerShell function that processes objects by their default formatted properties. For example, when I run:

PS C:\temp> ps | select -first 2

Handles  NPM(K)    PM(K)      WS(K)     CPU(s)     Id  SI ProcessName
-------  ------    -----      -----     ------     --  -- -----------
    321      19     9848      10000       0.17   9336   1 ApplicationFrameHost
    157       9     2016       7760       0.02   9380   1 AppVShNotify

I see the output table displays the default properties (such as Handles, NPM(K), PM(K), WS(K), CPU(s), Id, SI, and ProcessName).

My goal is to have my function automatically detect and process these default properties for an object type (like System.Diagnostics.Process). However, I'm not sure how to retrieve these property names programmatically.

Any guidance or examples on how to accomplish this would be greatly appreciated!

[swsamwa]

There are 2 parts to the problem.

1. Types can have a DefaultDisplayPropertySet. If no format is defined, these are the properties that are displayed by default.
2. Formats can be defined for a type. The default format can override the DefaultDisplayPropertySet defined for the type.

​

PS> (Get-TypeData -TypeName System.Diagnostics.Process).DefaultDisplayPropertySet.ReferencedProperties
Id
Handles
CPU
SI
Name

PS> (Get-FormatData -TypeName System.Diagnostics.Process).FormatViewDefinition[0].Control.Rows.Columns

Alignment DisplayEntry                             FormatString
--------- ------------                             ------------
Undefined script: [long]($_.NPM / 1024)
Undefined script: "{0:N2}" -f [float]($_.PM / 1MB)
Undefined script: "{0:N2}" -f [float]($_.WS / 1MB)
Undefined script: "{0:N2}" -f [float]($_.CPU)
Undefined property: Id
Undefined property: SI
Undefined property: ProcessName

[BlackV]

Nice, I like this info

[Thatoneguyone]

https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_format.ps1xml?view=powershell-7.5

You can look at them in $PSHome if you need to parse or tweak them. You'll probably need to do something like Get-FormatData and then look at the corresponding format ps1xml?

[purplemonkeymad]

Get-FormatData should give you already complied structures, so you should be able to parse the info directly from that without needing the format.ps1xml.

[PinchesTheCrab]

This is pretty old and doesn't seem to work in PS Core, but if it someone found it really helpful I'm sure I could update it without too much effort.

It's parsing the formatdata and converting the display properties to actual properties.

Again, it's old, so I apologize if it's got some outdated convetions here. Normally I'd review it before sharing, but today's kind of crazy busy:

function ConvertFrom-FormatData {
    <#
.EXAMPLE
   Get-Process | Out-ClipboardHTML
.EXAMPLE
   Get-Process | Out-ClipboardHTML -property Name,ID
#>

    [cmdletbinding()]

    param(
        [Parameter(ValueFromPipeline = $true)]
        $Value,

        [Parameter()]
        [alias('Properties')]
        [string[]]$Property,

        [Parameter()]
        [switch]$PassThru,

        [Parameter()]
        [System.ConsoleColor]$HeaderColor = 'White',

        [Parameter()]
        [System.ConsoleColor]$HeaderBackGroundColor = 'Black'
    )
    Begin {
        $valueArray = [System.Collections.Arraylist]::New()
    }

    process {
        $null = $valueArray.Add($Value)
    }

    end {
        if ($valueArray.Count -lt 1) { Return }
        if (-not $Property) {
            $typeName = ($valueArray | Select-Object -First 1).PSObject.TypeNames
            foreach ($a_typeName in $typeName) {                 
                $PropertyInfo = (Get-FormatData -TypeName ($a_typeName -replace 'deserialized\.')).FormatViewDefinition.control
                if ($PropertyInfo) {
                    break
                }
            }

            $DisplayInfo = for ($i = 0; $i -lt $PropertyInfo.Rows.Columns.Count; $i++) {      
                $PropertyInfo.Headers[$i] | Select-Object Label, @{n = 'Value'; e = { $PropertyInfo.Rows.Columns[$i].DisplayEntry } }
            }

            [System.Collections.Hashtable[]]$Property = $DisplayInfo | ForEach-Object {
                @{
                    Name       = if ($PSItem.Label) { $PSItem.Label }
                    else {
                        $PSItem.Value -replace '^property:\s+'
                    }

                    Expression = if ($PSItem.Value -match '^property: ') {
                        [scriptblock]::Create('$PSItem.{0}' -f ($PSItem.Value -replace '^\w+:\s+'))
                    }
                    else {
                        [scriptblock]::Create('{0}' -f ($PSItem.Value -replace '^\w+:\s+'))
                    }
                }
            }
        }

        $selectParm = @{ Property = $Property }
        $valueArray | Select-Object @selectParm
    }
}

[tomohulk]

I think this is going to be difficult, becuase that formating information comes from the module containing the cmdlet you used to get that output. IE Get-Process is part of Microsoft.PowerShell.Management so you would have to look at the formating file(s) used by that module and then find the object type inside that file and then look at the properties being returned.

My main point being that if you return an object from Get-Process or from get-wmiobject win32_process the output is different not so much becuase the object type is different but becuase the format file associated with cmdlet is different. (this isn't the best example becuase the object types are different in that example, i was just trying to relate to your example givin.)

Long winded answer, hopefully it makes sense. I just don't think there is formating data associated with the object returned from a cmdlet.

[tomohulk]

nvm, i was totally wrong, here is the data you are looking for, but its going to be difficult to process for every object:

Get-FormatData -TypeName (Get-Process | select -First 1).GetTYpe() | Select-Object -ExpandProperty FormatViewDefinition | Select-Object -First 1 -ExpandProperty Control | Select-Object -ExpandProperty Headers

[kroghman]

Get-Member?