Way to invoke a scriptblock with named parameters from C#

Summary of the new feature/enhancement

Say I have a scriptblock like this:

{
    param(
        $a,
        $b
    )

    "a: $a"
    "b: $b"
}

And I want to invoke it from C#:

var sb = ScriptBlock.Create("...");
var parameters = new Hashtable
{
    { "a", "A" },
    { "b", "B" },
};

sb.Invoke(?);
InvokeCommand.InvokeScript(sb, ?);

using (var pwsh = PowerShell.Create())
{
    pwsh.<?>.AddParameters(parameters).Invoke();
}

Is there a way to do this currently in PowerShell, and if not can we have one?

The best way I’ve found to do this so far is to use reflection to create a FunctionInfo object around the scriptblock for invocation:

var sb = ScriptBlock.Create("param($a, $b) \"a: $a\",\"b: $b\"");
var runspace = RunspaceFactory.CreateRunspace();
runspace.Open();

PropertyInfo runspaceExecutionContextProperty = typeof(Runspace).GetProperty("ExecutionContext", BindingFlags.Instance | BindingFlags.NonPublic);
Type ecType = runspaceExecutionContextProperty.PropertyType;

ConstructorInfo funcInfoCtor = typeof(FunctionInfo).GetConstructor(
    BindingFlags.NonPublic | BindingFlags.Instance,
    binder: null,
    new[] { typeof(string), typeof(ScriptBlock), ecType },
    modifiers: null);

object executionContext = runspaceExecutionContextProperty.GetValue(runspace);
var sbFuncInfo = (FunctionInfo)funcInfoCtor.Invoke(new object[] { string.Empty, sb, executionContext });

using (var pwsh = PowerShell.Create())
{
    pwsh.AddCommand(sbFuncInfo).AddParameters(new Dictionary<string, object>{ {"a", "A"}, {"b", "B"} });

    foreach (PSObject result in pwsh.Invoke())
    {
        Console.WriteLine(result);
    }
}

But this is very involved, messy, requires overhead and isn’t public/officially supported.

Proposed technical implementation details (optional)

Some considerations:

• While the PowerShell API is a good place for this, it doesn’t currently have good support for scriptblocks (something which could be improved)
• Other APIs do support scriptblocks well, such as CommandInvocationIntrinsics.InvokeScript and ScriptBlock.Invoke[WithContext] and it would be nice to extend those to enable named parameter passing since they allow simpler control of the execution context than the PowerShell API

[rjmholt]

While there is currently no support for passing a dictionary of arguments - i.e. no support for splatting via the PowerShell class - a chain of .AddParameter() calls is akin to that, if more verbose.

I believe AddParameters() does that.

The only real reason you’d want to do this is to invoke a scriptblock in the current runspace while retaining original AST information for debugging.

My primary reason is not wanting to rebuild a scriptblock. In my scenario, I’m taking in a user-provided scriptblock in a cmdlet and I want to execute it providing a set of parameters to choose from. I’d like that scriptblock to keep all of its context and metadata and not have the overhead of stringifying it just for PowerShell to construct a new one. That way, if something goes wrong in the execution, the error message makes sense to users.

[SeeminglyScience]

@rjmholt, wouldn’t introducing the following new ScriptBlock.InvokeWithContext() overload address your use case?

It may not matter in every use case, but it’s worth noting that the Invoke* methods have a lot of limitations (like end block only, very limited $MyInvocation, no error stream) and aren’t very performant.