How to forward pipeline input from a binary proxy cmdlet?

[MatejKafka]

There's a somewhat well-known pattern for implementing a proxy PowerShell function:

function Proxy {
	[CmdletBinding(...)]
	param(...) # either copy parameters manually ...

	dynamicparam {
		# ... or use dynamicparam
	}

	begin {
		$sb = {Wrapped-Command ...}
		$sp = $sb.GetSteppablePipeline()
		$sp.Begin($PSCmdlet)
	}

	process {
		$sp.Process($_)
	}

	end {
		$sp.End()
	}
}

For various reasons, I would like to implement a similar proxy as a binary cmdlet. Most parts map 1:1 between PowerShell and C#, but I can't seem to figure out what to do in the process block, since a compiled cmdlet does not have the automatic $_ variable containing the current pipeline input:

[Cmdlet(...)]
class ProxyCommand : ... {
    // copy parameters from wrapped cmdlet using dynamic parameters
    public object GetDynamicParameters() {...}

    private PowerShell _ps = PowerShell.Create();
    private SteppablePipeline? _pipeline;

    protected override void BeginProcessing() {
        base.BeginProcessing();

        _pipeline = _ps.GetSteppablePipeline();
        _pipeline.Begin(this);
    }

    protected override void ProcessRecord() {
        base.ProcessRecord();
        _pipeline!.Process(); // what do I do here, since I don't know which of the forwarded dynamic params accept pipeline input?
    }

    protected override void EndProcessing() {
        base.EndProcessing();
        _pipeline!.End();
    }
}

A possible option would be to manually check which of the possible pipeline parameters was filled from the pipeline and forward it, but that requires quite a lot of needless coupling between the proxy and the wrapped cmdlet. From a cursory inspection of the pipeline implementation in the PowerShell engine, I don't see a simple way to poke at the input object without a lot of reflection. Is there a clean solution to this problem?

[rhubarb-geek-nz]

Do you need

        [Parameter(Mandatory = true, ValueFromPipeline = true)]
        public string InputString;

And PowerrShell will populate that on each iteration of process record.

[MatejKafka]

The problem is that similarly to the PowerShell example, I'm copying parameters from the wrapped cmdlet, so I do not have control over them. The pipelined value will be bound to one of multiple possible proxied parameters, and I do not know which one (and would prefer not to know).

[MatejKafka]

I guess one dubious approach would be to remove ValueFromPipeline from all proxied parameters and add a generic InputObject parameter, which is passed to Process. The downside is that binding errors will be raised from the wrapped cmdlet, not from the proxy cmdlet, but it should work.

Still, I'm open to less hacky alternatives. :)

[SeeminglyScience]

I don't think there is a supported way to access that info at the moment. A less error prone (but not supported) path might be to access the internal property PSCmdlet.CurrentPipelineObject

[SeeminglyScience]

That said, there's nothing stopping you from binding the same pipeline input to two parameters:

function test {
    param(
        [Parameter(ValueFromPipeline)]
        [string] $AsString,

        [Parameter(ValueFromPipeline)]
        [object] $AsAnything
    )
    process {
        $AsString.GetType()
        $AsAnything.GetType()
    }
}

# yields both [string] and [int]
10 | test

Still might mess with binding in some situations though.

[MatejKafka]

TIL that there can be more than 1 bound pipeline parameter, interesting. :)

[rhubarb-geek-nz]

This uses legitimate methods..

#!/usr/bin/env pwsh

$code = @"
using System;
using System.Management.Automation;

[Cmdlet("Write", "Hello")]
public class WriteHello : PSCmdlet
{
	[Parameter(Mandatory = true, ValueFromPipeline = true)]
	public PSObject InputObject;

	private PowerShell _ps;

	private SteppablePipeline _pipeline;

	protected override void BeginProcessing()
	{
		base.BeginProcessing();

		_ps = PowerShell.Create();
		_ps.AddCommand("ConvertTo-JSON");
		_pipeline = _ps.GetSteppablePipeline();
		_pipeline.Begin(this);
	}

	protected override void ProcessRecord()
	{
		base.ProcessRecord();
		_pipeline.Process(InputObject);
	}

	protected override void EndProcessing()
	{
		base.EndProcessing();
		_pipeline.End();
		_ps.Dispose();
	}
}
"@

Add-Type $code

$WriteHello = [System.Management.Automation.CmdletInfo]::new("Write-Hello", [WriteHello])

$list = [char]'x', [char]'y', [char]'z'

'abcd' | & $WriteHello

$list | & $WriteHello

1..5 | & $WriteHello

Write-Output $list -NoEnumerate | & $WriteHello

The test cases pipe data in which are then passed to ConvertTo-JSON

"abcd"
[
  "x",
  "y",
  "z"
]
[
  1,
  2,
  3,
  4,
  5
]
[
  "x",
  "y",
  "z"
]