adapterExample.cs

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Management.Automation;

public sealed class MyCustomClass
{
    // Ideally this should be a hardcoded set of Methods or Properties that can be set on this object
    private static readonly HashSet<string> _selfMethods = new(
        typeof(MyCustomClass).GetMethods().Select(e => e.Name),
        StringComparer.OrdinalIgnoreCase);

    private readonly Dictionary<string, object?> _properties = new(StringComparer.OrdinalIgnoreCase);

    public object? this[string property]
    {
        get => _properties.TryGetValue(property, out object? value) ? value : null;
        set => _properties[property] = value;
    }

    internal Collection<PSAdaptedProperty> Properties
    {
        get => new([.. _properties.Select(kv => new PSAdaptedProperty(kv.Key, kv.Value))]);
    }

    // Check if the property passed to the adapter is actually a method, if so,
    // GetProperty has to return null so the adapter falls back to calling it
    internal static bool IsMethod(string property) => _selfMethods.Contains(property);
}

public sealed class MyPropertyAdapter : PSPropertyAdapter
{
    public override Collection<PSAdaptedProperty>? GetProperties(object baseObject)
        => baseObject is MyCustomClass customClass
            ? customClass.Properties : null;

    public override PSAdaptedProperty? GetProperty(object baseObject, string propertyName)
        => baseObject is MyCustomClass customClass && !MyCustomClass.IsMethod(propertyName)
            ? new(propertyName, customClass[propertyName]) : null;

    public override string? GetPropertyTypeName(PSAdaptedProperty adaptedProperty)
        => adaptedProperty.Tag?.GetType().Name;

    public override object? GetPropertyValue(PSAdaptedProperty adaptedProperty)
        => adaptedProperty.Tag;

    // Should always be True, makes no sense to have Property { set; } only
    public override bool IsGettable(PSAdaptedProperty adaptedProperty) => true;

    // Should be defined by the implementer, in this case, any dynamic property is settable
    public override bool IsSettable(PSAdaptedProperty adaptedProperty) => true;

    public override void SetPropertyValue(PSAdaptedProperty adaptedProperty, object value)
    {
        if (adaptedProperty.BaseObject is MyCustomClass customClass)
            customClass[adaptedProperty.Name] = value;
    }
}

Usage.md

Compile and load the type... this could be pre-compiled e.g. via dotnet CLI then the type loaded via Assembly.LoadFrom(...) or Add-Type or Import-Module if part of an actual PowerShell Module.

Once loaded you can Update-TypeData -TypeAdapter like shown in the example:

Add-Type -Path .\adapterExample.cs -WA 0 -IgnoreWarnings
Update-TypeData -TypeAdapter ([MyPropertyAdapter]) -TypeName ([MyCustomClass])

If the adapter is part of the a module you can have a ...Types.ps1xml instead and loaded via TypesToProcess:

<?xml version="1.0" encoding="utf-8"?>
<Types>
  <Type>
    <Name>MyCustomClass</Name>
    <TypeAdapter>
      <TypeName>MyPropertyAdapter</TypeName>
    </TypeAdapter>
  </Type>
</Types>

Then the actual usage, pretty much like an AD Object... it is actually ADEntityAdapter the one in charge of this...

$class = [MyCustomClass]::new()
$class.Id = [guid]::NewGuid()
$class.Name = 'john.galt'
$class

# Id                                   Name
# --                                   ----
# bbd94707-59b8-4de8-9624-89bfa2ca6700 john.galt

$class.psobject.Properties

# BaseObject      : MyCustomClass
# Tag             : bbd94707-59b8-4de8-9624-89bfa2ca6700
# MemberType      : Property
# Value           : bbd94707-59b8-4de8-9624-89bfa2ca6700
# IsSettable      : True
# IsGettable      : True
# TypeNameOfValue : Guid
# Name            : Id
# IsInstance      : True
#
# BaseObject      : MyCustomClass
# Tag             : john.galt
# MemberType      : Property
# Value           : john.galt
# IsSettable      : True
# IsGettable      : True
# TypeNameOfValue : String
# Name            : Name
# IsInstance      : True

Thanks for updating - works great.

In general, it's worth noting that property adapters are primarily designed for adapting preexisting, PowerShell-unaware types.

If, as in the case at hand, the property adapter must rely on internal members of the adapted type anyway, you could simplify the implementation by limiting it to simply exposing the dictionary storing the dynamic properties, and making the adapter do the rest.

---

On an unrelated note, re https://stackoverflow.com/q/79939851/45375:

• Unfortunately, it seems that you have to explicitly follow a post in order to be notified of responses.
• The fact that typing "@" doesn't offer auto-completion of potential addressees suggests that @-mentioning won't work either.