New-DynamicParameter.ps1

<#
.SYNOPSIS
	Helper function to simplify creating dynamic parameters

.DESCRIPTION
	Helper function to simplify creating dynamic parameters.

	Example use cases:
		Include parameters only if your environment dictates it
		Include parameters depending on the value of a user-specified parameter
		Provide tab completion and intellisense for parameters, depending on the environment

	Please keep in mind that all dynamic parameters you create, will not have corresponding variables created.
		Use New-DynamicParameter with 'CreateVariables' switch in your main code block,
		('Process' for advanced functions) to create those variables.
		Alternatively, manually reference $PSBoundParameters for the dynamic parameter value.

	This function has two operating modes:

	1. All dynamic parameters created in one pass using pipeline input to the function. This mode allows to create dynamic parameters en masse,
	with one function call. There is no need to create and maintain custom RuntimeDefinedParameterDictionary.

	2. Dynamic parameters are created by separate function calls and added to the RuntimeDefinedParameterDictionary you created beforehand.
	Then you output this RuntimeDefinedParameterDictionary to the pipeline. This allows more fine-grained control of the dynamic parameters,
	with custom conditions and so on.

.NOTES
	Credits to jrich523 and ramblingcookiemonster for their initial code and inspiration:
		https://github.com/RamblingCookieMonster/PowerShell/blob/master/New-DynamicParam.ps1
		http://ramblingcookiemonster.wordpress.com/2014/11/27/quick-hits-credentials-and-dynamic-parameters/
		http://jrich523.wordpress.com/2013/05/30/powershell-simple-way-to-add-dynamic-parameters-to-advanced-function/

	Credit to BM for alias and type parameters and their handling

.PARAMETER Name
	Name of the dynamic parameter

.PARAMETER Type
	Type for the dynamic parameter.  Default is string

.PARAMETER Alias
	If specified, one or more aliases to assign to the dynamic parameter

.PARAMETER Mandatory
	If specified, set the Mandatory attribute for this dynamic parameter

.PARAMETER Position
	If specified, set the Position attribute for this dynamic parameter

.PARAMETER HelpMessage
	If specified, set the HelpMessage for this dynamic parameter

.PARAMETER DontShow
	If specified, set the DontShow for this dynamic parameter.
	This is the new PowerShell 4.0 attribute that hides parameter from tab-completion.
	http://www.powershellmagazine.com/2013/07/29/pstip-hiding-parameters-from-tab-completion/

.PARAMETER ValueFromPipeline
	If specified, set the ValueFromPipeline attribute for this dynamic parameter

.PARAMETER ValueFromPipelineByPropertyName
	If specified, set the ValueFromPipelineByPropertyName attribute for this dynamic parameter

.PARAMETER ValueFromRemainingArguments
	If specified, set the ValueFromRemainingArguments attribute for this dynamic parameter

.PARAMETER ParameterSetName
	If specified, set the ParameterSet attribute for this dynamic parameter. By default parameter is added to all parameters sets.

.PARAMETER AllowNull
	If specified, set the AllowNull attribute of this dynamic parameter

.PARAMETER AllowEmptyString
	If specified, set the AllowEmptyString attribute of this dynamic parameter

.PARAMETER AllowEmptyCollection
	If specified, set the AllowEmptyCollection attribute of this dynamic parameter

.PARAMETER ValidateNotNull
	If specified, set the ValidateNotNull attribute of this dynamic parameter

.PARAMETER ValidateNotNullOrEmpty
	If specified, set the ValidateNotNullOrEmpty attribute of this dynamic parameter

.PARAMETER ValidateRange
	If specified, set the ValidateRange attribute of this dynamic parameter

.PARAMETER ValidateLength
	If specified, set the ValidateLength attribute of this dynamic parameter

.PARAMETER ValidatePattern
	If specified, set the ValidatePattern attribute of this dynamic parameter

.PARAMETER ValidateScript
	If specified, set the ValidateScript attribute of this dynamic parameter

.PARAMETER ValidateSet
	If specified, set the ValidateSet attribute of this dynamic parameter

.PARAMETER Dictionary
	If specified, add resulting RuntimeDefinedParameter to an existing RuntimeDefinedParameterDictionary.
	Appropriate for custom dynamic parameters creation.

	If not specified, create and return a RuntimeDefinedParameterDictionary
	Aappropriate for a simple dynamic parameter creation.

.EXAMPLE
	Create one dynamic parameter.

	This example illustrates the use of New-DynamicParameter to create a single dynamic parameter.
	The Drive's parameter ValidateSet is populated with all available volumes on the computer for handy tab completion / intellisense.

	Usage: Get-FreeSpace -Drive <tab>

	function Get-FreeSpace
	{
		[CmdletBinding()]
		Param()
		DynamicParam
		{
			# Get drive names for ValidateSet attribute
			$DriveList = ([System.IO.DriveInfo]::GetDrives()).Name

			# Create new dynamic parameter
			New-DynamicParameter -Name Drive -ValidateSet $DriveList -Type ([array]) -Position 0 -Mandatory
		}

		Process
		{
			# Dynamic parameters don't have corresponding variables created,
			# you need to call New-DynamicParameter with CreateVariables switch to fix that.
			New-DynamicParameter -CreateVariables -BoundParameters $PSBoundParameters

			$DriveInfo = [System.IO.DriveInfo]::GetDrives() | Where-Object {$Drive -contains $_.Name}
			$DriveInfo |
				ForEach-Object {
					if(!$_.TotalFreeSpace)
					{
						$FreePct = 0
					}
					else
					{
						$FreePct = [System.Math]::Round(($_.TotalSize / $_.TotalFreeSpace), 2)
					}
					New-Object -TypeName psobject -Property @{
						Drive = $_.Name
						DriveType = $_.DriveType
						'Free(%)' = $FreePct
					}
				}
		}
	}

.EXAMPLE
	Create several dynamic parameters not using custom RuntimeDefinedParameterDictionary (requires piping).

	In this example two dynamic parameters are created. Each parameter belongs to the different parameter set, so they are mutually exclusive.

	The Drive's parameter ValidateSet is populated with all available volumes on the computer.
	The DriveType's parameter ValidateSet is populated with all available drive types.

	Usage: Get-FreeSpace -Drive <tab>
		or
	Usage: Get-FreeSpace -DriveType <tab>

	Parameters are defined in the array of hashtables, which is then piped through the New-Object to create PSObject and pass it to the New-DynamicParameter function.
	Because of piping, New-DynamicParameter function is able to create all parameters at once, thus eliminating need for you to create and pass external RuntimeDefinedParameterDictionary to it.

	function Get-FreeSpace
	{
		[CmdletBinding()]
		Param()
		DynamicParam
		{
			# Array of hashtables that hold values for dynamic parameters
			$DynamicParameters = @(
				@{
					Name = 'Drive'
					Type = [array]
					Position = 0
					Mandatory = $true
					ValidateSet = ([System.IO.DriveInfo]::GetDrives()).Name
					ParameterSetName = 'Drive'
				},
				@{
					Name = 'DriveType'
					Type = [array]
					Position = 0
					Mandatory = $true
					ValidateSet = [System.Enum]::GetNames('System.IO.DriveType')
					ParameterSetName = 'DriveType'
				}
			)

			# Convert hashtables to PSObjects and pipe them to the New-DynamicParameter,
			# to create all dynamic paramters in one function call.
			$DynamicParameters | ForEach-Object {New-Object PSObject -Property $_} | New-DynamicParameter
		}
		Process
		{
			# Dynamic parameters don't have corresponding variables created,
			# you need to call New-DynamicParameter with CreateVariables switch to fix that.
			New-DynamicParameter -CreateVariables -BoundParameters $PSBoundParameters

			if($Drive)
			{
				$Filter = {$Drive -contains $_.Name}
			}
			elseif($DriveType)
			{
				$Filter =  {$DriveType -contains  $_.DriveType}
			}

			$DriveInfo = [System.IO.DriveInfo]::GetDrives() | Where-Object $Filter
			$DriveInfo |
				ForEach-Object {
					if(!$_.TotalFreeSpace)
					{
						$FreePct = 0
					}
					else
					{
						$FreePct = [System.Math]::Round(($_.TotalSize / $_.TotalFreeSpace), 2)
					}
					New-Object -TypeName psobject -Property @{
						Drive = $_.Name
						DriveType = $_.DriveType
						'Free(%)' = $FreePct
					}
				}
		}
	}

.EXAMPLE
	Create several dynamic parameters, with multiple Parameter Sets, not using custom RuntimeDefinedParameterDictionary (requires piping).

	In this example three dynamic parameters are created. Two of the parameters are belong to the different parameter set, so they are mutually exclusive.
	One of the parameters belongs to both parameter sets.

	The Drive's parameter ValidateSet is populated with all available volumes on the computer.
	The DriveType's parameter ValidateSet is populated with all available drive types.
	The DriveType's parameter ValidateSet is populated with all available drive types.
	The Precision's parameter controls number of digits after decimal separator for Free Space percentage.

	Usage: Get-FreeSpace -Drive <tab> -Precision 2
		or
	Usage: Get-FreeSpace -DriveType <tab> -Precision 2

	Parameters are defined in the array of hashtables, which is then piped through the New-Object to create PSObject and pass it to the New-DynamicParameter function.
	If parameter with the same name already exist in the RuntimeDefinedParameterDictionary, a new Parameter Set is added to it.
	Because of piping, New-DynamicParameter function is able to create all parameters at once, thus eliminating need for you to create and pass external RuntimeDefinedParameterDictionary to it.

	function Get-FreeSpace
	{
		[CmdletBinding()]
		Param()
		DynamicParam
		{
			# Array of hashtables that hold values for dynamic parameters
			$DynamicParameters = @(
				@{
					Name = 'Drive'
					Type = [array]
					Position = 0
					Mandatory = $true
					ValidateSet = ([System.IO.DriveInfo]::GetDrives()).Name
					ParameterSetName = 'Drive'
				},
				@{
					Name = 'DriveType'
					Type = [array]
					Position = 0
					Mandatory = $true
					ValidateSet = [System.Enum]::GetNames('System.IO.DriveType')
					ParameterSetName = 'DriveType'
				},
				@{
					Name = 'Precision'
					Type = [int]
					# This will add a Drive parameter set to the parameter
					Position = 1
					ParameterSetName = 'Drive'
				},
				@{
					Name = 'Precision'
					# Because the parameter already exits in the RuntimeDefinedParameterDictionary,
					# this will add a DriveType parameter set to the parameter.
					Position = 1
					ParameterSetName = 'DriveType'
				}
			)

			# Convert hashtables to PSObjects and pipe them to the New-DynamicParameter,
			# to create all dynamic paramters in one function call.
			$DynamicParameters | ForEach-Object {New-Object PSObject -Property $_} | New-DynamicParameter
		}
		Process
		{
			# Dynamic parameters don't have corresponding variables created,
			# you need to call New-DynamicParameter with CreateVariables switch to fix that.
			New-DynamicParameter -CreateVariables -BoundParameters $PSBoundParameters

			if($Drive)
			{
				$Filter = {$Drive -contains $_.Name}
			}
			elseif($DriveType)
			{
				$Filter = {$DriveType -contains  $_.DriveType}
			}

			if(!$Precision)
			{
				$Precision = 2
			}

			$DriveInfo = [System.IO.DriveInfo]::GetDrives() | Where-Object $Filter
			$DriveInfo |
				ForEach-Object {
					if(!$_.TotalFreeSpace)
					{
						$FreePct = 0
					}
					else
					{
						$FreePct = [System.Math]::Round(($_.TotalSize / $_.TotalFreeSpace), $Precision)
					}
					New-Object -TypeName psobject -Property @{
						Drive = $_.Name
						DriveType = $_.DriveType
						'Free(%)' = $FreePct
					}
				}
		}
	}

.Example
	Create dynamic parameters using custom dictionary.

	In case you need more control, use custom dictionary to precisely choose what dynamic parameters to create and when.
	The example below will create DriveType dynamic parameter only if today is not a Friday:

	function Get-FreeSpace
	{
		[CmdletBinding()]
		Param()
		DynamicParam
		{
			$Drive = @{
				Name = 'Drive'
				Type = [array]
				Position = 0
				Mandatory = $true
				ValidateSet = ([System.IO.DriveInfo]::GetDrives()).Name
				ParameterSetName = 'Drive'
			}

			$DriveType =  @{
				Name = 'DriveType'
				Type = [array]
				Position = 0
				Mandatory = $true
				ValidateSet = [System.Enum]::GetNames('System.IO.DriveType')
				ParameterSetName = 'DriveType'
			}

			# Create dictionary
			$DynamicParameters = New-Object System.Management.Automation.RuntimeDefinedParameterDictionary

			# Add new dynamic parameter to dictionary
			New-DynamicParameter @Drive -Dictionary $DynamicParameters

			# Add another dynamic parameter to dictionary, only if today is not a Friday
			if((Get-Date).DayOfWeek -ne [DayOfWeek]::Friday)
			{
				New-DynamicParameter @DriveType -Dictionary $DynamicParameters
			}

			# Return dictionary with dynamic parameters
			$DynamicParameters
		}
		Process
		{
			# Dynamic parameters don't have corresponding variables created,
			# you need to call New-DynamicParameter with CreateVariables switch to fix that.
			New-DynamicParameter -CreateVariables -BoundParameters $PSBoundParameters

			if($Drive)
			{
				$Filter = {$Drive -contains $_.Name}
			}
			elseif($DriveType)
			{
				$Filter =  {$DriveType -contains  $_.DriveType}
			}

			$DriveInfo = [System.IO.DriveInfo]::GetDrives() | Where-Object $Filter
			$DriveInfo |
				ForEach-Object {
					if(!$_.TotalFreeSpace)
					{
						$FreePct = 0
					}
					else
					{
						$FreePct = [System.Math]::Round(($_.TotalSize / $_.TotalFreeSpace), 2)
					}
					New-Object -TypeName psobject -Property @{
						Drive = $_.Name
						DriveType = $_.DriveType
						'Free(%)' = $FreePct
					}
				}
		}
	}
#>
Function New-DynamicParameter {
	[CmdletBinding(PositionalBinding = $false, DefaultParameterSetName = 'DynamicParameter')]
	Param
	(
		[Parameter(Mandatory = $true, ValueFromPipeline = $true, ValueFromPipelineByPropertyName = $true, ParameterSetName = 'DynamicParameter')]
		[ValidateNotNullOrEmpty()]
		[string]$Name,

		[Parameter(ValueFromPipelineByPropertyName = $true, ParameterSetName = 'DynamicParameter')]
		[System.Type]$Type = [int],

		[Parameter(ValueFromPipelineByPropertyName = $true, ParameterSetName = 'DynamicParameter')]
		[string[]]$Alias,

		[Parameter(ValueFromPipelineByPropertyName = $true, ParameterSetName = 'DynamicParameter')]
		[switch]$Mandatory,

		[Parameter(ValueFromPipelineByPropertyName = $true, ParameterSetName = 'DynamicParameter')]
		[int]$Position,

		[Parameter(ValueFromPipelineByPropertyName = $true, ParameterSetName = 'DynamicParameter')]
		[string]$HelpMessage,

		[Parameter(ValueFromPipelineByPropertyName = $true, ParameterSetName = 'DynamicParameter')]
		[switch]$DontShow,

		[Parameter(ValueFromPipelineByPropertyName = $true, ParameterSetName = 'DynamicParameter')]
		[switch]$ValueFromPipeline,

		[Parameter(ValueFromPipelineByPropertyName = $true, ParameterSetName = 'DynamicParameter')]
		[switch]$ValueFromPipelineByPropertyName,

		[Parameter(ValueFromPipelineByPropertyName = $true, ParameterSetName = 'DynamicParameter')]
		[switch]$ValueFromRemainingArguments,

		[Parameter(ValueFromPipelineByPropertyName = $true, ParameterSetName = 'DynamicParameter')]
		[string]$ParameterSetName = '__AllParameterSets',

		[Parameter(ValueFromPipelineByPropertyName = $true, ParameterSetName = 'DynamicParameter')]
		[switch]$AllowNull,

		[Parameter(ValueFromPipelineByPropertyName = $true, ParameterSetName = 'DynamicParameter')]
		[switch]$AllowEmptyString,

		[Parameter(ValueFromPipelineByPropertyName = $true, ParameterSetName = 'DynamicParameter')]
		[switch]$AllowEmptyCollection,

		[Parameter(ValueFromPipelineByPropertyName = $true, ParameterSetName = 'DynamicParameter')]
		[switch]$ValidateNotNull,

		[Parameter(ValueFromPipelineByPropertyName = $true, ParameterSetName = 'DynamicParameter')]
		[switch]$ValidateNotNullOrEmpty,

		[Parameter(ValueFromPipelineByPropertyName = $true, ParameterSetName = 'DynamicParameter')]
		[ValidateCount(2,2)]
		[int[]]$ValidateCount,

		[Parameter(ValueFromPipelineByPropertyName = $true, ParameterSetName = 'DynamicParameter')]
		[ValidateCount(2,2)]
		[int[]]$ValidateRange,

		[Parameter(ValueFromPipelineByPropertyName = $true, ParameterSetName = 'DynamicParameter')]
		[ValidateCount(2,2)]
		[int[]]$ValidateLength,

		[Parameter(ValueFromPipelineByPropertyName = $true, ParameterSetName = 'DynamicParameter')]
		[ValidateNotNullOrEmpty()]
		[string]$ValidatePattern,

		[Parameter(ValueFromPipelineByPropertyName = $true, ParameterSetName = 'DynamicParameter')]
		[ValidateNotNullOrEmpty()]
		[scriptblock]$ValidateScript,

		[Parameter(ValueFromPipelineByPropertyName = $true, ParameterSetName = 'DynamicParameter')]
		[ValidateNotNullOrEmpty()]
		[string[]]$ValidateSet,

		[Parameter(ValueFromPipelineByPropertyName = $true, ParameterSetName = 'DynamicParameter')]
		[ValidateNotNullOrEmpty()]
		[ValidateScript({
			if(!($_ -is [System.Management.Automation.RuntimeDefinedParameterDictionary]))
			{
				Throw 'Dictionary must be a System.Management.Automation.RuntimeDefinedParameterDictionary object'
			}
			$true
		})]
		$Dictionary = $false,

		[Parameter(Mandatory = $true, ValueFromPipelineByPropertyName = $true, ParameterSetName = 'CreateVariables')]
		[switch]$CreateVariables,

		[Parameter(Mandatory = $true, ValueFromPipelineByPropertyName = $true, ParameterSetName = 'CreateVariables')]
		[ValidateNotNullOrEmpty()]
		[ValidateScript({
			# System.Management.Automation.PSBoundParametersDictionary is an internal sealed class,
			# so one can't use PowerShell's '-is' operator to validate type.
			if($_.GetType().Name -ne 'PSBoundParametersDictionary')
			{
				Throw 'BoundParameters must be a System.Management.Automation.PSBoundParametersDictionary object'
			}
			$true
		})]
		$BoundParameters
	)

	Begin
	{
		Write-Verbose 'Creating new dynamic parameters dictionary'
		$InternalDictionary = New-Object -TypeName System.Management.Automation.RuntimeDefinedParameterDictionary

		Write-Verbose 'Getting common parameters'
		function _temp { [CmdletBinding()] Param() }
		$CommonParameters = (Get-Command _temp).Parameters.Keys
	}

	Process
	{
		if($CreateVariables)
		{
			Write-Verbose 'Creating variables from bound parameters'
			Write-Debug 'Picking out bound parameters that are not in common parameters set'
			$BoundKeys = $BoundParameters.Keys | Where-Object { $CommonParameters -notcontains $_ }

			foreach($Parameter in $BoundKeys)
			{
				Write-Debug "Setting existing variable for dynamic parameter '$Parameter' with value '$($BoundParameters.$Parameter)'"
				Set-Variable -Name $Parameter -Value $BoundParameters.$Parameter -Scope 1 -Force
			}
		}
		else
		{
			Write-Verbose 'Looking for cached bound parameters'
			Write-Debug 'More info: https://beatcracker.wordpress.com/2014/12/18/psboundparameters-pipeline-and-the-valuefrompipelinebypropertyname-parameter-attribute'
			$StaleKeys = @()
			$StaleKeys = $PSBoundParameters.GetEnumerator() |
						ForEach-Object {
							if($_.Value.PSobject.Methods.Name -match '^Equals$')
							{
								# If object has Equals, compare bound key and variable using it
								if(!$_.Value.Equals((Get-Variable -Name $_.Key -ValueOnly -Scope 0)))
								{
									$_.Key
								}
							}
							else
							{
								# If object doesn't has Equals (e.g. $null), fallback to the PowerShell's -ne operator
								if($_.Value -ne (Get-Variable -Name $_.Key -ValueOnly -Scope 0))
								{
									$_.Key
								}
							}
						}
			if($StaleKeys)
			{
				[string[]]"Found $($StaleKeys.Count) cached bound parameters:" +  $StaleKeys | Write-Debug
				Write-Verbose 'Removing cached bound parameters'
				$StaleKeys | ForEach-Object {[void]$PSBoundParameters.Remove($_)}
			}

			# Since we rely solely on $PSBoundParameters, we don't have access to default values for unbound parameters
			Write-Verbose 'Looking for unbound parameters with default values'

			Write-Debug 'Getting unbound parameters list'
			$UnboundParameters = (Get-Command -Name ($PSCmdlet.MyInvocation.InvocationName)).Parameters.GetEnumerator()  |
										# Find parameters that are belong to the current parameter set
										Where-Object { $_.Value.ParameterSets.Keys -contains $PsCmdlet.ParameterSetName } |
											Select-Object -ExpandProperty Key |
												# Find unbound parameters in the current parameter set
												Where-Object { $PSBoundParameters.Keys -notcontains $_ }

			# Even if parameter is not bound, corresponding variable is created with parameter's default value (if specified)
			Write-Debug 'Trying to get variables with default parameter value and create a new bound parameter''s'
			$tmp = $null
			foreach($Parameter in $UnboundParameters)
			{
				$DefaultValue = Get-Variable -Name $Parameter -ValueOnly -Scope 0
				if(!$PSBoundParameters.TryGetValue($Parameter, [ref]$tmp) -and $DefaultValue)
				{
					$PSBoundParameters.$Parameter = $DefaultValue
					Write-Debug "Added new parameter '$Parameter' with value '$DefaultValue'"
				}
			}

			if($Dictionary)
			{
				Write-Verbose 'Using external dynamic parameter dictionary'
				$DPDictionary = $Dictionary
			}
			else
			{
				Write-Verbose 'Using internal dynamic parameter dictionary'
				$DPDictionary = $InternalDictionary
			}

			Write-Verbose "Creating new dynamic parameter: $Name"

			# Shortcut for getting local variables
			$GetVar = {Get-Variable -Name $_ -ValueOnly -Scope 0}

			# Strings to match attributes and validation arguments
			$AttributeRegex = '^(Mandatory|Position|ParameterSetName|DontShow|HelpMessage|ValueFromPipeline|ValueFromPipelineByPropertyName|ValueFromRemainingArguments)$'
			$ValidationRegex = '^(AllowNull|AllowEmptyString|AllowEmptyCollection|ValidateCount|ValidateLength|ValidatePattern|ValidateRange|ValidateScript|ValidateSet|ValidateNotNull|ValidateNotNullOrEmpty)$'
			$AliasRegex = '^Alias$'

			Write-Debug 'Creating new parameter''s attirubutes object'
			$ParameterAttribute = New-Object -TypeName System.Management.Automation.ParameterAttribute

			Write-Debug 'Looping through the bound parameters, setting attirubutes...'
			switch -regex ($PSBoundParameters.Keys)
			{
				$AttributeRegex
				{
					Try
					{
						$ParameterAttribute.$_ = . $GetVar
						Write-Debug "Added new parameter attribute: $_"
					}
					Catch
					{
						$_
					}
					continue
				}
			}

			if($DPDictionary.Keys -contains $Name)
			{
				Write-Verbose "Dynamic parameter '$Name' already exist, adding another parameter set to it"
				$DPDictionary.$Name.Attributes.Add($ParameterAttribute)
			}
			else
			{
				Write-Verbose "Dynamic parameter '$Name' doesn't exist, creating"

				Write-Debug 'Creating new attribute collection object'
				$AttributeCollection = New-Object -TypeName Collections.ObjectModel.Collection[System.Attribute]

				Write-Debug 'Looping through bound parameters, adding attributes'
				switch -regex ($PSBoundParameters.Keys)
				{
					$ValidationRegex
					{
						Try
						{
							$ParameterOptions = New-Object -TypeName "System.Management.Automation.${_}Attribute" -ArgumentList (. $GetVar) -ErrorAction Stop
							$AttributeCollection.Add($ParameterOptions)
							Write-Debug "Added attribute: $_"
						}
						Catch
						{
							$_
						}
						continue
					}

					$AliasRegex
					{
						Try
						{
							$ParameterAlias = New-Object -TypeName System.Management.Automation.AliasAttribute -ArgumentList (. $GetVar) -ErrorAction Stop
							$AttributeCollection.Add($ParameterAlias)
							Write-Debug "Added alias: $_"
							continue
						}
						Catch
						{
							$_
						}
					}
				}

				Write-Debug 'Adding attributes to the attribute collection'
				$AttributeCollection.Add($ParameterAttribute)

				Write-Debug 'Finishing creation of the new dynamic parameter'
				$Parameter = New-Object -TypeName System.Management.Automation.RuntimeDefinedParameter -ArgumentList @($Name, $Type, $AttributeCollection)

				Write-Debug 'Adding dynamic parameter to the dynamic parameter dictionary'
				$DPDictionary.Add($Name, $Parameter)
			}
		}
	}

	End
	{
		if(!$CreateVariables -and !$Dictionary)
		{
			Write-Verbose 'Writing dynamic parameter dictionary to the pipeline'
			$DPDictionary
		}
	}
}