Comparing PowerShell Property Names

Recently, I was chatting with my friend Gladys Kravitz about the hassle of comparing objects in PowerShell. Even after all these years. She has a specific use case, but you might also feel the need for a better comparison option. And to be clear, the comparison we're talking about is not the object's values, as you might see with Compare-Object. But rather the property names.

In Gladys' situation, she imports data from CSV files which she processes through her scripts to get things done. Her use-case is to compare property names. Does this CSV file have the same property names as that CSV file? Are there extra properties? Or is something missing? So let's see how we might address this.

Think Objects

Even though we're starting with CSV files, we're really talking about objects. Gladys can import her CSV files and turn them into custom objects. You might be creating objects to compare through some other mechanism. The bottom line is that we should look at this as an object comparison problem, not a file problem.

Let me start by generating some sample data.

$csvA = @"
samantha,darren-1,darren-2,tabitha,esmerelda
1,2,3,4,5
2,4,6,8,10
3,6,9,11,12
11,22,33,44,55
"@

$csvB = @"
samantha,darren-1,darren-2,esmerelda,gladys,agatha
1,2,3,4,0,9
2,4,6,8,1,8
3,6,9,11,8,0
11,22,33,55,66,77
"@

$a = $csvA | ConvertFrom-Csv
$b = $csvB | ConvertFrom-Csv

For my purposes $A is the reference object and the $B is the difference object. In looking at the data you can see the $B is missing "tabitha" and has extra properties "agatha" and "gladys". I don't care about the values. We even don't really care about the order of property names because one we have an object we're going to reference by property name, not its position in the CSV header.

PSObject

To compare object property names, we don't need the entire object. All we need is one item to analyze because the property names are the same for objects. PowerShell goes to a lot of effort to make it easy to use for IT Pros. PowerShell hides a lot of the .NET sausage-making so you only have to work with the final results. But sometimes, we need to get our hands dirty. In this case, we're going to use a ubiquitous property called PSObject.

We're going to use the Properties property. Here's what it looks like.

It is easy then to create a list of property names for the reference and difference objects.

$refProp = $a[0].psobject.properties.name | Sort-Object
$diffProp = $b[0].psobject.properties.name | Sort-Object

Then I can go through each list and see what properties are missing or extra.

#find extra  properties in the difference object
foreach ($name in $diffProp) {
    if ($refProp -notcontains $name) {
      $name
    }
} #foreach

#find missing reference properties from the difference object
foreach ($name in $refProp) {
    if ($diffProp -notcontains $name) {
       $name
    }
} #foreach

Of course, I want to create a meaningful result so that Gladys can tell at a glance how things compare.

Compare-PropertyName

Here's the PowerShell function I wrote.

Function Compare-PropertyName {
    [cmdletbinding(DefaultParameterSetName="default")]
    [alias("cpn")]
    [Outputtype("PSPropertyNameDifference","string","boolean")]
    Param(
        [Parameter(Position = 0, Mandatory)]
        [ValidateNotNullOrEmpty()]
        [object]$Reference,
        [Parameter(Position = 1, Mandatory)]
        [ValidateNotNullOrEmpty()]
        [object]$Difference,
        [Parameter(HelpMessage = "Indicate if property names match with a simple True/False.",ParameterSetName="quiet")]
        [switch]$Quiet,
        [Parameter(HelpMessage = "Only show missing property names in the difference object.",ParameterSetName="missing")]
        [switch]$MissingOnly,
        [Parameter(HelpMessage = "Only show extra property names in the difference object.",ParameterSetName="extra")]
        [switch]$ExtraOnly
    )

    #get property names from the first item
    $refProp = $Reference[0].psobject.properties.name | Sort-Object
    Write-Verbose "Found $(($refProp).count) reference properties"

    $diffProp = $Difference[0].psobject.properties.name | Sort-Object
    Write-Verbose "Found $(($diffProp). count) difference properties"

    $missing = [System.Collections.Generic.List[string]]::new()
    $extra = [System.Collections.Generic.List[string]]::new()

    #find extra  properties in the difference object
    foreach ($name in $diffProp) {
        if ($refProp -notcontains $name) {
            Write-Verbose "$Name not found in the reference object"
            $extra.Add( $name)
        }
    } #foreach

    #find missing reference properties from the difference object
    foreach ($name in $refProp) {
        if ($diffProp -notcontains $name) {
            Write-Verbose "$Name not found in the difference object"
            $missing.Add( $name)
        }
    } #foreach

    #create a custom object for the reseult
    $result = [pscustomobject]@{
            PSTypename = "PSPropertyNameDifference"
            Missing = $missing
            Extra = $Extra
            ReferenceProperties = $refProp
            DifferenceProperties = $diffProp
            ReferenceCount = $refProp.count
            DifferenceCount = $diffProp.count
         }

         switch ($pscmdlet.ParameterSetName) {
            "Quiet" {
                if ($result.missing.count -eq 0 -AND $result.extra.count -eq 0) {
                    $true
                }
                else {
                    $false
                }
            }
            "Missing" {
                $result.Missing
            }
            "Extra" {
                $result.Extra
            }
            Default {
                $result
            }
         } #switch


} #close function

The function generates one type of object by default.

But I also wanted to offer alternatives that would give Gladys information she might want quickly.

The results are all relative to the difference object. The difference object, $b, is missing the property "tabitha", for example.

I'd love to hear how this works for you. I think this will make a good addition to the PSScriptTools module so look for an update in the next few weeks.