Efficient method for setting "unknown" property of "unknown" type to "unknown" value?

I'm trying to create an automated method to set the properties of an object, when the property name, type, and value are variable.

Example:

I have a WinForms form ([System.Windows.Forms.Form]) and I want to set the Size, TopMost, and Dock properties. I'm getting these values via JSON:

"properties": [
    {
        "name": "Size",
        "type": "System.Drawing.Size",
        "value": {
            "width": 500,
            "height": 500
        }
    },
    {
        "name": "TopMost",
        "type": "System.Boolean",
        "value": true
    },
    {
        "name": "Dock",
        "type": "System.Windows.Forms.DockStyle",
        "value": "Right"
    }
]

The problem is, since each of those properties are different types, they all have to be set in different ways:

$form.Size = [System.Drawing.Size]::new(500, 500)
$form.TopMost = $true
$form.Dock = [System.Windows.Forms.DockStyle]::Right

Right now I'm using a switch statement:

switch -regex ($property.type){
    "^System\.Drawing\.Size$" {
        $form.$($property.name) = [system.drawing.size]::new($property.value.width, $property.value.height)
    }
    "^System\.Windows\.Forms\.DockStyle)$" {
        $type = [type]$($property.type)
        $form.$($property.name) = $type::$($property.value)
    }
    "^System\.(String|Boolean)$" {
        $form.$($property.name) = $property.value
    }
    Default {
        $type = [type]$($property.type)
        $form.$($property.name) = $type::new($($property.value))
    }
}

The Default case I'm using doesn't work for a lot of types, so any time I come across a new type that I want to use, I have to update the switch statement. System.Windows.Forms.FlowDirection, for example, is an enum like DockStyle, so I have to update that case statement:

"^System\.Windows\.Forms\.(DockStyle|FlowDirection))$" {
    $type = [type]$($property.type)
    $form.$($property.name) = $type::$($property.value)
}

Is there a single, unified method that will work, no matter the type?

Per comments, there's no bullet-proof built-in mechanism for deserailising from your json format. Here's an incomplete approach though that has generalised handling for some common types (enums, value types, classes with constructors that meet certain constraints)...

First, set up a test context (note I've changed the form size so the width and height are different so we can prove they're set the right way round):

$ErrorActionPreference = "Stop";
Set-StrictMode -Version "Latest";

$properties = @"
{
  "properties": [
    {
      "name": "Size",
      "type": "System.Drawing.Size",
      "value": {
        "width": 1024,
        "height": 768
      }
    },
    {
      "name": "TopMost",
      "type": "System.Boolean",
      "value": true
    },
    {
      "name": "Dock",
      "type": "System.Windows.Forms.DockStyle",
      "value": "Right"
    }
  ]
}
"@ | ConvertFrom-Json;

Add-Type -Assembly "System.Windows.Forms";
$form = new-object System.Windows.Forms.Form;

and then we can use reflection to inspect the form's properties for each item in the json.

Depending on the type of the form's property we can do some generalised processing that will work with some restrictions - for example for object properties there must be a public constructor for the type with parameter names that match fields in the json. If that's not true for a given type you'll still need to add a special handler for that type...

foreach( $property in $properties.properties )
{
    write-host $property.name;

    # needs error handling!
    $propertyType = $form.GetType().GetProperty($property.Name).PropertyType;

    # handle simple types
    if( $propertyType -in @( [bool], [string], [int32], [int64] ) )
    {
        write-host "    simple type";
        write-host "    $($propertyType.FullName)";
        write-host "    '$($property.value)'";
        $form.($property.Name) = $property.value;
        continue;
    }

    # is the form property an enum?
    if( $propertyType.IsEnum )
    {
        # powershell will automatically convert a string to the appropriate enum type
        write-host "    enum";
        write-host "    $($propertyType.FullName)";
        write-host "    '$($property.value)'";
        $form.($property.Name) = $property.value;
        continue;
    }

    # can we create an object using a constructor?
    if( $property.value -is [System.Management.Automation.PSCustomObject] )
    {
        write-host "    constructor";
        write-host "    $($propertyType.FullName)";
        # can we find an appropriate constructor for the type?
        $valueNames = @( $property.value.psobject.Properties.Name );
        $constructors = @(
            $propertyType.GetConstructors() `
                | where-object {
                    $params = $_.GetParameters();
                    # not the right constructor if it's got a different number of parameters
                    if( -not ($params.Length -eq $valueNames.Length ) )
                    {
                        return $false;
                    }
                    # are there any constructor parameters
                    # that don't appear in the json?
                    $missing = $params | where-object {
                        $valueNames -notcontains $_.Name
                    }
                    return ($null -eq $missing)
                }
        );
        if( $constructors.Length -ne 1 )
        {
            throw "couldn't match to exactly one constructor";
        }
        write-host "    $($constructor.ToString())";
        # note - we don't verify json value types are compatible with the constructor parameter types
        $paramValues = @(
            $constructor.GetParameters() | foreach-object {
                # use "-as" to cast the json value to the correct type for the constructor parameter
                write-host "    $($_.ParameterType.Name) $($_.Name) = '$($property.value.($_.Name))'";
                $property.value.($_.Name) -as $_.ParameterType
            };
        )
        $form.($property.Name) = $constructors[0].Invoke($paramValues);
        continue;
    }

    # don't know what to do with this type
    throw "unhandled property type '$($propertyType.FullName)'";
   
}

the logging output from this is:

Size
constructor
System.Drawing.Size
Void .ctor(Int32, Int32)
Int32 width = '1024'
Int32 height = '768'
TopMost
simple type
System.Boolean
'True'
Dock
enum
System.Windows.Forms.DockStyle
'Right'

and the resulting form looks like this:

$form | fl Size, TopMost, Dock
# Size    : {Width=1024, Height=768}
# TopMost : True
# Dock    : Right

This should work with most of the common System.Windows.Forms.Form properties, but will probably fail quite quickly if you try to use it as a general-purpose deserialiser for other types...

> Is there a single, unified method that will work, no matter the type?

Probably not, but you can improve your current approach:

• Use the -as operator for type conversions
• Resolve the type name ahead of time instead of using regex to identify it
• Add special parsing for [System.Boolean]

# resolve the type
$type = $property.type -as [type]
# convert and assign
$form."$($property.Name)" = switch ($type) {
{$_ -eq [bool]} {
[bool]::Parse($property.value)
}
default {
$property.value -as $type
}
}