Function New-PSDynamicParameter {

[cmdletbinding()]

[alias("ndp")]

[outputtype([System.String[]])]

Param(

[Parameter(Position = 0, Mandatory, HelpMessage = "Enter the name of your dynamic parameter.`nThis is a required value.")]

[ValidateNotNullOrEmpty()]

[alias("Name")]

[string[]]$ParameterName,

[Parameter(Mandatory, HelpMessage = "Enter an expression that evaluates to True or False.`nThis is code that will go inside an IF statement.`nIf using variables, wrap this in single quotes.`nYou can also enter a placeholder like '`$True' and edit it later.`nThis is a required value.")]

[ValidateNotNullOrEmpty()]

[string]$Condition,

[Parameter(HelpMessage = "Is this dynamic parameter mandatory?")]

[switch]$Mandatory,

[Parameter(HelpMessage = "Enter an optional default value.")]

[object[]]$DefaultValue,

[Parameter(HelpMessage = "Enter an optional parameter alias.`nSpecify multiple aliases separated by commas.")]

[string[]]$Alias,

[Parameter(HelpMessage = "Enter the parameter value type such as String or Int32.`nUse a value like string[] to indicate an array.")]

[type]$ParameterType = "string",

[Parameter(HelpMessage = "Enter an optional help message.")]

[ValidateNotNullOrEmpty()]

[string]$HelpMessage,

[Parameter(HelpMessage = "Does this dynamic parameter take pipeline input by property name?")]

[switch]$ValueFromPipelineByPropertyName,

[Parameter(HelpMessage = "Enter an optional parameter set name.")]

[ValidateNotNullOrEmpty()]

[string]$ParameterSetName,

[Parameter(HelpMessage = "Enter an optional comment for your dynamic parameter.`nIt will be inserted into your code as a comment.")]

[ValidateNotNullOrEmpty()]

[string]$Comment,

[Parameter(HelpMessage = "Validate that the parameter is not NULL or empty.")]

[switch]$ValidateNotNullOrEmpty,

[Parameter(HelpMessage = "Enter a minimum and maximum string length for this parameter value`nas an array of comma-separated set values.")]

[ValidateNotNullOrEmpty()]

[int[]]$ValidateLength,

[Parameter(HelpMessage = "Enter a set of parameter validations values")]

[ValidateNotNullOrEmpty()]

[object[]]$ValidateSet,

[Parameter(HelpMessage = "Enter a set of parameter range validations values as a`ncomma-separated list from minimum to maximum")]

[ValidateNotNullOrEmpty()]

[int[]]$ValidateRange,

[Parameter(HelpMessage = "Enter a set of parameter count validations values as a`ncomma-separated list from minimum to maximum")]

[ValidateNotNullOrEmpty()]

[int[]]$ValidateCount,

[Parameter(HelpMessage = "Enter a parameter validation regular expression pattern")]

[ValidateNotNullOrEmpty()]

[string]$ValidatePattern,

[Parameter(HelpMessage = "Enter a parameter validation scriptblock.`nIf using the form, enter the scriptblock text.")]

[ValidateNotNullOrEmpty()]

[scriptblock]$ValidateScript

)

Begin {

Write-Verbose "[$((Get-Date).TimeofDay) BEGIN ] Starting $($myinvocation.mycommand)"

$out = @"

} #begin

Process {

if (-Not $($PSBoundParameters.ContainsKey("ParameterSetName"))) {

$PSBoundParameters.Add("ParameterSetName", "__AllParameterSets")

}

#get validation tests

$Validations = $PSBoundParameters.GetEnumerator().Where({ $_.key -match "^Validate" })

#this is structured for future development where you might need to create

#multiple dynamic parameters. This feature is incomplete at this time

Foreach ($Name in $ParameterName) {

Write-Verbose "[$((Get-Date).TimeofDay) PROCESS] Defining dynamic parameter $Name [$($parametertype.name)]"

$out += "`n # Defining parameter attributes`n"

$out += " `$attributeCollection = New-Object -Type System.Collections.ObjectModel.Collection[System.Attribute]`n"

$out += " `$attributes = New-Object System.Management.Automation.ParameterAttribute`n"

#add attributes

$attributeProperties = 'ParameterSetName', 'Mandatory', 'ValueFromPipeline', 'ValueFromPipelineByPropertyName', 'ValueFromRemainingArguments', 'HelpMessage'

foreach ($item in $attributeProperties) {

if ($PSBoundParameters.ContainsKey($item)) {

Write-Verbose "[$((Get-Date).TimeofDay) PROCESS] Defining $item"

if ( $PSBoundParameters[$item] -is [string]) {

$value = "'$($PSBoundParameters[$item])'"

}

else {

$value = "`$$($PSBoundParameters[$item])"

}

$out += " `$attributes.$item = $value`n"

}

}

#add parameter validations

if ($validations) {

Write-Verbose "[$((Get-Date).TimeofDay) PROCESS] Processing validations"

foreach ($validation in $Validations) {

Write-Verbose "[$((Get-Date).TimeofDay) PROCESS] ... $($validation.key)"

$out += "`n # Adding $($validation.key) parameter validation`n"

Switch ($Validation.key) {

"ValidateNotNullOrEmpty" {

$out += " `$v = New-Object System.Management.Automation.ValidateNotNullOrEmptyAttribute`n"

$out += " `$AttributeCollection.Add(`$v)`n"

}

"ValidateLength" {

$out += " `$value = @($($Validation.Value[0]),$($Validation.Value[1]))`n"

$out += " `$v = New-Object System.Management.Automation.ValidateLengthAttribute(`$value)`n"

$out += " `$AttributeCollection.Add(`$v)`n"

}

"ValidateSet" {

$join = "'$($Validation.Value -join "','")'"

$out += " `$value = @($join) `n"

$out += " `$v = New-Object System.Management.Automation.ValidateSetAttribute(`$value)`n"

$out += " `$AttributeCollection.Add(`$v)`n"

}

"ValidateRange" {

$out += " `$value = @($($Validation.Value[0]),$($Validation.Value[1]))`n"

$out += " `$v = New-Object System.Management.Automation.ValidateRangeAttribute(`$value)`n"

$out += " `$AttributeCollection.Add(`$v)`n"

}

"ValidatePattern" {

$out += " `$value = '$($Validation.value)'`n"

$out += " `$v = New-Object System.Management.Automation.ValidatePatternAttribute(`$value)`n"

$out += " `$AttributeCollection.Add(`$v)`n"

}

"ValidateScript" {

$out += " `$value = {$($Validation.value)}`n"

$out += " `$v = New-Object System.Management.Automation.ValidateScriptAttribute(`$value)`n"

$out += " `$AttributeCollection.Add(`$v)`n"

}

"ValidateCount" {

$out += " `$value = @($($Validation.Value[0]),$($Validation.Value[1]))`n"

$out += " `$v = New-Object System.Management.Automation.ValidateCountAttribute(`$value)`n"

$out += " `$AttributeCollection.Add(`$v)`n"

}

} #close switch

} #foreach validation

} #validations

$out += " `$attributeCollection.Add(`$attributes)`n"

if ($Alias) {

Write-Verbose "[$((Get-Date).TimeofDay) PROCESS] Adding parameter alias $($alias -join ',')"

Foreach ($item in $alias) {

$out += "`n # Adding a parameter alias`n"

$out += " `$dynalias = New-Object System.Management.Automation.AliasAttribute -ArgumentList '$Item'`n"

$out += " `$attributeCollection.Add(`$dynalias)`n"

}

}

$out += "`n # Defining the runtime parameter`n"

#handle the Switch parameter since it uses a slightly different name

if ($ParameterType.Name -match "Switch") {

$paramType = "Switch"

}

else {

$paramType = $ParameterType.Name

}

$out += " `$dynParam1 = New-Object -Type System.Management.Automation.RuntimeDefinedParameter('$Name', [$paramType], `$attributeCollection)`n"

if ($DefaultValue) {

Write-Verbose "[$((Get-Date).TimeofDay) PROCESS] Using default value $($DefaultValue)"

if ( $DefaultValue[0] -is [string]) {

$value = "'$($DefaultValue)'"

}

else {

$value = "`$$($DefaultValue)"

}

$out += " `$dynParam1.Value = $value`n"

}

$Out += @"

} #foreach dynamic parameter name

}

End {

$out += @"

$out

Write-Verbose "[$((Get-Date).TimeofDay) END ] Ending $($myinvocation.mycommand)"

} #end

}

Function New-PSDynamicParameterForm {

[cmdletbinding()]

[alias("dpf")]

[Outputtype("None")]

Param()

Try {

Add-`Type -AssemblyName PresentationFramework -ErrorAction stop

Add-Type -AssemblyName PresentationCore -ErrorAction Stop

}

Catch {

Write-Warning "This command is not compatible with this version of PowerShell."

Return

}

$list = [System.Collections.Generic.list[object]]::new()

[xml]$xaml = @"

$reader = New-Object System.Xml.XmlNodeReader $xaml

$Window = [Windows.Markup.XamlReader]::Load($reader)

#get all parameters

$all = (Get-Command New-PSDynamicParameter).parameters

#filter out common parameters

$common = [System.Management.Automation.Cmdlet]::CommonParameters

$paramList = $all.GetEnumerator().where({$common -notcontains $_.key}).key

#get controls

foreach ($item in $paramList) {

Write-Verbose "Processing control $item"

Try {

$tmp = New-Variable -Name $item -Value ($Window.FindName($item)) -ErrorAction Stop -PassThru

#add a help tool tip

$tip = $all[$item].attributes.where({$_.typeid.name -eq 'parameterattribute'}).helpMessage

write-Verbose "Found help $tip"

$tmp.Value.ToolTip = $tip

$list.Add((Get-Variable -Name $item))

}

Catch {

Write-Verbose "Skipping $item"

}

}

#hook up code to buttons

$OK = $Window.FindName("OK")

$OK.ToolTip = "Create the dynamic parameter code and copy to the clipboard.`nThis will NOT close the form."

$OK.Add_Click({

Write-Verbose "Defining dynamic parameter $($ParameterName.text)"

$splat = @{}

$list | where-object {$_.value.text} | foreach-object {

$splat.Add($_.Name,$_.value.Text)

}

#add switches

$list | where-object {$_.value.IsChecked} | foreach-object {

$splat.Add($_.Name,$True)

}

#turn values into arrays as needed

$Names = "ValidateSet","ValidateCount","ValidateRange","ValidateLength"

foreach ($n in $names) {

if ($splat[$n]) {

$splat[$n] = $splat[$n].split(",")

}

}

#convert ValidateScript text into a scriptblock

if ($splat["ValidateScript"]) {

$splat["ValidateScript"] = [scriptblock]::Create($splat["ValidateScript"])

}

New-PSDynamicParameter @splat | Set-Clipboard

Write-Host "Your dynamic parameter code has been copied to the clipboard. Paste it into your script file." -ForegroundColor Green

})

$Quit = $Window.FindName("Quit")

$Quit.Add_Click({$window.close()})

[void]$window.Activate()

[void]$window.ShowDialog()

}

if ($host.name -eq 'Visual Studio Code Host') {

Register-EditorCommand -Name "DynamicParameterForm" -DisplayName "Define a dynamic parameter" -ScriptBlock (Get-Item -path Function:\New-PSDynamicParameterForm).scriptblock -SuppressOutput

}

elseif ($host.name -match "PowerShell ISE") {

if ($psise.CurrentPowerShellTab.AddOnsMenu.Submenus.DisplayName -notcontains "New Dynamic Parameter") {

$action = {New-PSDynamicParameterForm}

[void]($Psise.CurrentPowerShellTab.AddOnsMenu.Submenus.Add("New Dynamic Parameter", $action, "Ctrl+Alt+D"))

}

}