Complex data types, byReference arguments and data not changing as expected

Question

I have a function that can either initialize itself and return an ordered dictionary with initial values, or if a collection is provided as an argument, it manipulates that collection. And that collection is a key within a parent collection.

In my actual code I am seeing an odd behavior, where a key in the initial collection is initially $Null or has a specified value, but when I try to revise that value I do NOT get an error, but I also do not get a changed value. However, when I try creating a minimally functional example to post here, it does work correctly, both in the console and the IDE.

So, given this code

function Write-Data {
    param (
        [System.Collections.Specialized.OrderedDictionary]$Collection
    )

    foreach ($key in $Collection.Keys) {
        try {
            $type = $Collection.$key.GetType().FullName
        } catch {
            $type = 'NULL'
        }
        Write-Host "$key $type $($Collection.$key)"
    }
    Write-Host
}

function Manage-Data {
    param (
        [System.Collections.Specialized.OrderedDictionary]$Collection
    )

    if (-not $Collection) {
        [System.Collections.Specialized.OrderedDictionary]$initialCollection = [Ordered]@{
            initialNull = $null
            initialString = 'initial string'
        }
        return $initialCollection
    } else {
        $Collection.initialNull = 'No longer null'
        $Collection.initialString = 'New String'
    }
}

CLS
$parentContainer = New-Object System.Collections.Specialized.OrderedDictionary
$parentContainer.Add('data', (Manage-Data))

Write-Data $parentContainer.data
Manage-Data -Collection $parentContainer.data
Write-Data $parentContainer.data

is there any obvious scenario where either of the lines revising values would not throw an error, but would also not change the value? For example, if there are actually more functions doing other things with that initialized collection object before the attempt to revise data? Or perhaps more generally, since I am depending on the default byReference behavior of complex objects, is there some situation where this behavior breaks down and I am effectively modifying a new complex object when I think I am modifying the original? Or is the fact that I am having problems with a simple data type within the complex type potentially the issue?

For what it is worth, the idea here is to basically be able to use Dependency Injection, but with functions rather than classes, and also mimic to some extent the the concept of a constructor and a method in a class, but again in a function. And that has generally been working well, if a little messy, which has reenforced in my mind that I need to move to classes eventually. But this particular issue has me worried that I will see the same problem in classes, and unless I can understand it now I will have issues. But since I can't seem to recreate the issue in a simplified example, I seem to be unable to figure anything out.

It occurs to me that one thing I haven't tried is to actually get the memory address of the collection I think I am modifying, or even of the individual key, so I can verify I actually am changing the same data that I initialized. But HOW to get the memory address of a variable escapes me, and is maybe not possible in PowerShell or .NET?

Answer 1

"the default byReference behavior of complex objects" concerns the properties of the object not the object itself:

The difference between (if):

[System.Collections.Specialized.OrderedDictionary]$initialCollection = [Ordered]@{
    initialNull = $null
    initialString = 'initial string'
}

and (else)

$Collection.initialNull = 'No longer null'
$Collection.initialString = 'New String'

Is that the later (else) statements indeed change the values of the parent values as $Collection refers to the same object as $parentContainer.data but the former (if) statement creates a new $initialCollection in the scope of the Manage-Data function which isn't visible in the parent (even if you assign it to $Collection, it would create a new object reference in the scope of the Manage-Data function).

You might return $initialCollection but then, how are you handling the different returns (either a $initialCollection or enumerable null ) in your parent function? Therefore I would just return $initialCollection for both conditions and reassign the object (where the properties are still by reference and only the $parentContainer.data reference will change/reset):

$parentContainer.data = Manage-Data -Collection $parentContainer.data

Potential problems
In other words, the potential issue in your Manage-Data function lies in the fact that parent function needs a different approach in calling it based on the condition if (-not $Collection) which is actually defined within the function. (What will be the value of this condition, as the caller already need to act differently on the condition?)
This leaves two pitfalls:

• You call the function in the assumption that the argument is not a collection but it actually is:

$parentContainer = [Ordered]@{ data = [Ordered]@{} }
$parentContainer.Add('data', (Manage-Data))

In this case you get an error:

MethodInvocationException: Exception calling "Add" with "2" argument(s): "Item has already been added. Key in dictionary: 'data' Key being added: 'data'"

• And the opposite (which is less obvious): you call the function in the assumption that the argument is a collection but it is actually not:

$parentContainer = [Ordered]@{}
Manage-Data $ParentContainer.Data

This will leave an unexpected object on the pipeline:
^{(See: PowerShell Pipeline Pollution)}

Name                           Value
----                           -----
initialNull
initialString                  initial string

And doesn't add anything to the $parentContainer object:

$parentContainer # doesn't return anything as it doesn't contain anything

Suggestions

• See about scopes
• Enable Set-StrictMode -Version Latest.
  This will show you that a property is potentially empty.
• Use ([ref]$MyVar).Value = 'new value' to replace a value in a parent scope.
• (not related to the question) Use the IDictionary interface: [Collections.IDictionary]$Collection to accept a more general collection type in your functions.