Can I force input key names remain as such, rather than become values of key and value? If so, how?

[RokeJulianLockhart]

Examples

Get-ItemProperty -LiteralPath 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion' | Format-List

The aforementioned command outputs the undermentioned data:

SystemRoot                : C:\WINDOWS
BuildBranch               : ge_release
BuildLab                  : 26100.ge_release.240331-1435
BuildLabEx                : 26100.1.amd64fre.ge_release.240331-1435
CompositionEditionID      : Enterprise
CurrentBuild              : 26100
CurrentBuildNumber        : 26100
CurrentMajorVersionNumber : 10
CurrentMinorVersionNumber : 0
CurrentType               : Multiprocessor Free
CurrentVersion            : 6.3
DisplayVersion            : 24H2
EditionID                 : Professional
InstallationType          : Client
InstallDate               : 1719779588
LCUVer                    : 10.0.26100.2152
ProductName               : Windows 10 Pro

This is valid YAML (albeit not intentionally so). What matters for this discussion is that in the first line (and all) the key name is SystemRoot, and the value, C:\WINDOWS.

However, if I put it through ConvertTo-YAML, as undermentioned:

$YAML = @'
SystemRoot                : C:\WINDOWS
BuildBranch               : ge_release
BuildLab                  : 26100.ge_release.240331-1435
BuildLabEx                : 26100.1.amd64fre.ge_release.240331-1435
CompositionEditionID      : Enterprise
CurrentBuild              : 26100
CurrentBuildNumber        : 26100
CurrentMajorVersionNumber : 10
CurrentMinorVersionNumber : 0
CurrentType               : Multiprocessor Free
CurrentVersion            : 6.3
DisplayVersion            : 24H2
EditionID                 : Professional
InstallationType          : Client
InstallDate               : 1719779588
LCUVer                    : 10.0.26100.2152
ProductName               : Windows 10 Pro
'@
$YAML | ConvertFrom-YAML | Format-List

...the output is as undermentioned:

Name  : InstallDate
Value : 1719779588

Name  : BuildLab
Value : 26100.ge_release.240331-1435

Name  : EditionID
Value : Professional

Name  : CompositionEditionID
Value : Enterprise

Name  : CurrentType
Value : Multiprocessor Free

Name  : ProductName
Value : Windows 10 Pro

Name  : LCUVer
Value : 10.0.26100.2152

Name  : BuildBranch
Value : ge_release

Name  : CurrentMajorVersionNumber
Value : 10

Name  : CurrentBuildNumber
Value : 26100

Name  : CurrentVersion
Value : 6.3

Name  : CurrentMinorVersionNumber
Value : 0

Name  : DisplayVersion
Value : 24H2

Name  : BuildLabEx
Value : 26100.1.amd64fre.ge_release.240331-1435

Name  : SystemRoot
Value : C:\WINDOWS

Name  : InstallationType
Value : Client

Name  : CurrentBuild
Value : 26100

The differences are most visible if I utilize the undermentioned command:

$YAML | ConvertFrom-YAML | Format-Table -AutoSize

...where the output is actually more akin to that of Format-List, due to the encapsulation of these values:

Name                      Value
----                      -----
InstallDate               1719779588
BuildLab                  26100.ge_release.240331-1435
EditionID                 Professional
CompositionEditionID      Enterprise
CurrentType               Multiprocessor Free
ProductName               Windows 10 Pro
LCUVer                    10.0.26100.2152
BuildBranch               ge_release
CurrentMajorVersionNumber 10
CurrentBuildNumber        26100
CurrentVersion            6.3
CurrentMinorVersionNumber 0
DisplayVersion            24H2
BuildLabEx                26100.1.amd64fre.ge_release.240331-1435
SystemRoot                C:\WINDOWS
InstallationType          Client
CurrentBuild              26100

Questions

1. Why does it encapsulate the values with standard names? This is a very different format to its input. I'm rather surprised that it's so transformative by default.
2. Irrespective, can it be disabled? If not, might I know why?

[gabriel-samfira]

That is a particularity of Format-List when you give it a Hash Table. It's not encapsulated in anything. A hash table is a key-value pair data structure. As such, Format-List will format a hash table in 2 fields: Name and Value.

[RokeJulianLockhart]

That is a particularity of Format-List when you give it a Hash Table.

@gabriel-samfira, that doesn't make much sense to me, considering that the difference is also evident when using Format-Table, as aforestated.

As an example, consider how when it's exported to JSON and reimported to a PSObject, the keys and values are not subordinate to a Name and Value key respectively. Undermentioned, I attempt to demonstrate this using a more concise example, and the default ConvertTo-JSON command:

1. #!/usr/bin/env -S pwsh
   Install-Module -Name 'MonitorConfig' -RequiredVersion 1.0.3
   $DeviceName = '\\.\DISPLAY1'

2. • 1. Get-Monitor -DeviceName "$DeviceName" | ConvertTo-YAML

     2. LogicalDisplay:
        IsPrimary: true
        DeviceName: '\\.\DISPLAY1'
        Bounds:
          left: 0
          top: 0
          right: 2560
          bottom: 1440
        WorkingArea:
          left: 0
          top: 0
          right: 2560
          bottom: 1392
        FriendlyName: Generic PnP Monitor
        InstanceName: DISPLAY\BNQ7F87\7&1a33d6cf&1&UID256

   • 1. Get-Monitor -DeviceName "$DeviceName" | ConvertTo-JSON

     2. {
        "LogicalDisplay": {
        	"IsPrimary": true,
        	"DeviceName": "\\\\.\\DISPLAY1",
        	"Bounds": {
        	"left": 0,
        	"top": 0,
        	"right": 2560,
        	"bottom": 1440
        	},
        	"WorkingArea": {
        	"left": 0,
        	"top": 0,
        	"right": 2560,
        	"bottom": 1392
        	}
        },
        "FriendlyName": "Generic PnP Monitor",
        "InstanceName": "DISPLAY\\BNQ7F87\\7&1a33d6cf&1&UID256"
        }

3. $JSON = (Get-Monitor -DeviceName "$DeviceName" | ConvertTo-JSON)
   $YAML = (Get-Monitor -DeviceName "$DeviceName" | ConvertTo-YAML)

4. • 1. $JSON | ConvertFrom-JSON | Format-List

     2. LogicalDisplay : @{IsPrimary=True; DeviceName=\\.\DISPLAY1; Bounds=; WorkingArea=}
        FriendlyName   : Generic PnP Monitor
        InstanceName   : DISPLAY\BNQ7F87\7&1a33d6cf&1&UID256

   • 1. $YAML | ConvertFrom-YAML | Format-List

     2. Name  : LogicalDisplay
        Value : {[DeviceName, \\.\DISPLAY1], [Bounds, System.Collections.Hashtable], [IsPrimary, True], [WorkingArea, System.Collections.Hashtable]}
        
        Name  : InstanceName
        Value : DISPLAY\BNQ7F87\7&1a33d6cf&1&UID256
        
        Name  : FriendlyName
        Value : Generic PnP Monitor

[gabriel-samfira]

PsCustomObjects are not hash tables or dictionaries. They are different data structures. Powershell-yaml uses hashtables for mappings. The built in json commandlets use PsCustomObjects.

If you pass a hashtable or dictionary to Format-List it will give you the output you saw.

So the questions are: do you absolutely need PsCustomObjects? Is the issue that Format-List handles hash tables differently than PsCustomObjects? Is there an issue you're encountering when using hashtables instead of PsCustomObjects outside of how Format-list displays the contents of the hashtable?

[RokeJulianLockhart]

If you pass a hashtable or dictionary to Format-List it will give you the output you saw.

@gabriel-samfira, indeed:

1. 1. [PSCustomObject]@{'Name'='Test'; 'Status'='Commenced'} | Format-List

   2. Name   : Test
      Status : Commenced

2. 1. @{'Name'='Test'; 'Status'='Commenced'} | Format-List   

   2. Name  : Status
      Value : Commenced
      
      Name  : Name
      Value : Test

Thanks for this. I wasn't aware. I've now got a lot of stuff to convert from hashtables to PSCustomObjects. I wonder whether the PowerShell team would consider an FR to modify this.

So the questions are: do you absolutely need PsCustomObjects? Is the issue that Format-List handles hash tables differently than PsCustomObjects? Is there an issue you're encountering when using hashtables instead of PsCustomObjects outside of how Format-list displays the contents of the hashtable?

I'm quite confident that it is. As an example, although inside a script it's probably possible to remap them to what I expect, using ConvertFrom-YAML in the CLI is quite unpleasant because I must either use Format-Table to get something approaching Format-List, or I must source a format alternative to YAML for the original data.

[gabriel-samfira]

If you're using the hashtable inside a script, referencing the keys is almost identical to PsCustomObjects. I find it more pleasant to work with hashtables than PsCustomObjects especially when you have to iterate.

But if formatting in the CLI is the issue (not working with them in a script) if you simply print the value of a hashtable, you get the same thing you would if you pass a PsCustomObject to Format-List. See the output from the (irellevant) answer I gave about ordering.

The only difference from what Format-List gives you is the fact that printing the hashtable as is to the CLI will include the "Name, Value" header, and maybe some prettier coloring of keys.

[RokeJulianLockhart]

1. But if formatting in the CLI is the issue (not working with them in a script) if you simply print the value of a hashtable, you get the same thing you would if you pass a PSCustomObject to Format-List. See the output from the (irrelevant) answer I gave about ordering.

   @gabriel-samfira, apologies if this is silly of me, but are you certain? I ask because the sole method by which I know how to (the undermentioned) doesn't appear to allow this:

   #!/usr/bin/env -S pwsh
   $YAML = @'
   LogicalDisplay:
   IsPrimary: true
   DeviceName: '\\.\DISPLAY1'
   Bounds:
     left: 0
     top: 0
     right: 2560
     bottom: 1440
   WorkingArea:
     left: 0
     top: 0
     right: 2560
     bottom: 1392
   FriendlyName: Generic PnP Monitor
   InstanceName: DISPLAY\BNQ7F87\7&1a33d6cf&1&UID256
   '@
   $YAML | ConvertFrom-YAML -Ordered | Select-Object -Property 'Value'

   ...the output is:

   Value
   -----
   
   

   Solely referencing a singular key functions, and solely either the value or name:

   1. ($YAML | ConvertFrom-YAML).InstanceName

   2. DISPLAY\BNQ7F87\7&1a33d6cf&1&UID256
      

2. The only difference from what Format-List gives you is the fact that printing the hashtable as is to the CLI will include the "Name, Value" header, and maybe some prettier coloring of keys.

   :<

[gabriel-samfira]

Yeah. Here's a few examples:

Deserialize yaml:

PS /home/gabriel/Documents> $YAML = @'                                           
>> LogicalDisplay:  
>> IsPrimary: true
>> DeviceName: '\\.\DISPLAY1'
>> Bounds:
>>   left: 0
>>   top: 0
>>   right: 2560
>>   bottom: 1440
>> WorkingArea:
>>   left: 0
>>   top: 0
>>   right: 2560
>>   bottom: 1392
>> FriendlyName: Generic PnP Monitor
>> InstanceName: DISPLAY\BNQ7F87\7&1a33d6cf&1&UID256
>> '@

PS /home/gabriel/Documents> $obj = ConvertFrom-Yaml $YAML

Dump the whole hashtable:

PS /home/gabriel/Documents> $obj

Name                           Value
----                           -----
FriendlyName                   Generic PnP Monitor
DeviceName                     \\.\DISPLAY1
IsPrimary                      True
WorkingArea                    {[bottom, 1392], [top, 0], [right, 2560], [left, 0]}
LogicalDisplay                 
Bounds                         {[bottom, 1440], [top, 0], [right, 2560], [left, 0]}
InstanceName                   DISPLAY\BNQ7F87\7&1a33d6cf&1&UID256

Get the value of one key using dot notation:

PS /home/gabriel/Documents> $obj.FriendlyName                                    
Generic PnP Monitor

Using bracket notation:

PS /home/gabriel/Documents> $obj["FriendlyName"]
Generic PnP Monitor

Use Where-Object to search through keys:

PS /home/gabriel/Documents> $obj.GetEnumerator() | ? {$_.Name -eq "FriendlyName" }

Name                           Value
----                           -----
FriendlyName                   Generic PnP Monitor

Search through values with partial match:

PS /home/gabriel/Documents> $obj.GetEnumerator() | ? {$_.Value -Like "Generic*" } 

Name                           Value
----                           -----
FriendlyName                   Generic PnP Monitor

Loop over the hash map:

foreach ($item in $obj.GetEnumerator()) {
   Write-Output ("{0} --> {1}" -f ($item.Name, $item.Value)) 
}

Hash maps are the native key/value pair data structure in powershell. PSCustomObjects are great when you need to extend functionality. But they come at a cost of memory, speed, etc.

[gabriel-samfira]

If you are refering to the fact that the resulting deserialized object does not have the keys in the same order as the original yaml, then you can just add the -Ordered flag to ConvertFrom-Yaml:

PS /home/gabriel> $YAML | ConvertFrom-YAML -Ordered      

Name                           Value
----                           -----
SystemRoot                     C:\WINDOWS
BuildBranch                    ge_release
BuildLab                       26100.ge_release.240331-1435
BuildLabEx                     26100.1.amd64fre.ge_release.240331-1435
CompositionEditionID           Enterprise
CurrentBuild                   26100
CurrentBuildNumber             26100
CurrentMajorVersionNumber      10
CurrentMinorVersionNumber      0
CurrentType                    Multiprocessor Free
CurrentVersion                 6.3
DisplayVersion                 24H2
EditionID                      Professional
InstallationType               Client
InstallDate                    1719779588
LCUVer                         10.0.26100.2152
ProductName                    Windows 10 Pro

PS /home/gabriel> $YAML                            
SystemRoot                : C:\WINDOWS
BuildBranch               : ge_release
BuildLab                  : 26100.ge_release.240331-1435
BuildLabEx                : 26100.1.amd64fre.ge_release.240331-1435
CompositionEditionID      : Enterprise
CurrentBuild              : 26100
CurrentBuildNumber        : 26100
CurrentMajorVersionNumber : 10
CurrentMinorVersionNumber : 0
CurrentType               : Multiprocessor Free
CurrentVersion            : 6.3
DisplayVersion            : 24H2
EditionID                 : Professional
InstallationType          : Client
InstallDate               : 1719779588
LCUVer                    : 10.0.26100.2152
ProductName               : Windows 10 Pro

[gabriel-samfira]

Without the -Ordered flag, you get a hash table. With it, you get an ordered dictionary. The difference is that ordered dictionaries will (internally) use a list to ensure the order of the keys. Hash tables do not preserve the order. The main focus is speed of insert/lookup/delete operations.

[RokeJulianLockhart]

#151 (reply in thread)

@gabriel-samfira, I don't quite understand your focus upon the order, for although - as you state - the referenced flag causes the output to differ in its type according to PowerShell, the important aspect of its output does not appear to.

[gabriel-samfira]

I mentioned the order, because it wasn't quite clear what the issue was. Powershell-yaml uses hashtables and dictionaries for mappings. Those data structures, when passed to Format-List will be formatted as you saw. So I didn't exactly understand what the issue was, so I assumed it may have been the order of the keys.

In any case, ignore the comment about ordering.

[RokeJulianLockhart]

#151 (reply in thread)

@gabriel-samfira, many thanks for the assistance regardless.