Powershell: coerce or cast to type as named in a string variable

Question

I am trying to use the method outlined here to create a number of custom data types, and rather than having a line for each I would like to define a hash table of the names and types like this

$pxAccelerators = @{
   pxListObject = '[System.Collections.Generic.List[Object]]'
   pxListString = '[System.Collections.Generic.List[String]]'
   pxOrderedDictionary = '[System.Collections.Specialized.OrderedDictionary]'
}

Then I could use something like this

$typeAccelerators = [PowerShell].Assembly.GetType("System.Management.Automation.TypeAccelerators")
foreach ($key in $pxAccelerators.Keys) {
    $name = $key
    $type = $pxAccelerators.$key
    $typeAccelerators::Add($key,$type)
}

to loop through the hash table and add each one. However, the issue of course is that $type isn't an actual type, it's a string. And $typeAccelerators::Add($key,$type) needs a string and an actual type. So basically I need to coerce a string like '[System.Collections.Specialized.OrderedDictionary]' to the actual type. I have found plenty of references to casting or coercing from one data type to another, but I can't seem to find any reference to how to convert a string to a type as defined BY the string. I have tried all these stabs in the dark

([System.Type]'[System.Collections.ArrayList]')::new()
[System.Type]'[System.Collections.ArrayList]'
[System.Type]'[System.Collections.ArrayList]' -as [System.Type]
'[System.Collections.ArrayList]' -as ([PowerShell].Assembly.GetType('[System.Collections.ArrayList]')

to no avail. $type = ([PowerShell].Assembly.GetType('[System.Collections.ArrayList]')) seems to work, in that it doesn't throw an exception. But $type.GetType() does throw You cannot call a method on a null-valued expression.. Interestingly, auto completion with [PowerShell].Assembly.GetType('[System.Collections.ArrayList]'). shows properties like BaseType and FullName are available, suggesting that I have actually produced a type, but using .GetType() on the result throws an exception. I tried

$pxAccelerators = @{
   pxListObject = 'System.Collections.Generic.List[Object]'
   pxListString = 'System.Collections.Generic.List[String]'
   pxOrderedDictionary = 'System.Collections.Specialized.OrderedDictionary'
}
$typeAccelerators = [PowerShell].Assembly.GetType("System.Management.Automation.TypeAccelerators")
foreach ($key in $pxAccelerators.Keys) {
    $name = $key
    $type = [PowerShell].Assembly.GetType($pxAccelerators.$key)
    $typeAccelerators::Add($key,$type)
}

[PSObject].Assembly.GetType("System.Management.Automation.TypeAccelerators")::Get

and the accelerators are being added, but the type to be acclerated is not there, suggesting that the GetType() line is not actually producing a type.

Lastly, I found this which seems to be getting closer. But I can't seem to rock how to access the method without starting from some sort of type already, and [System.Type].GetType('System.Int32') is throwing, so that seems to be a dead end.

Am I trying to do something impossible? Or just missing the proper mechanism?

Answer 1

-as [type] will do

The -as operator gladly takes a type name as it's right-hand side operand.

Change the values of your dictionary to contain just a valid type name, and it becomes as easy as:

$pxAccelerators = @{
   pxListObject = 'System.Collections.Generic.List[Object]'
   pxListString = 'System.Collections.Generic.List[String]'
   pxOrderedDictionary = 'System.Collections.Specialized.OrderedDictionary'
}

$typeAccelerators = [PowerShell].Assembly.GetType("System.Management.Automation.TypeAccelerators")
foreach ($acc in $pxAccelerators.GetEnumerator()) {
    $name = $acc.Key
    $type = $acc.Value -as [type]
    $typeAccelerators::Add($name,$type)
}

Result:

PS ~> [pxOrderedDictionary] -is [type]
True
PS ~> [pxOrderedDictionary].FullName
System.Collections.Specialized.OrderedDictionary

Answer 2

Ultimately, your only problem was that you accidentally enclosed your type-name string values in [...] (e.g, '[System.Collections.ArrayList]'), whereas this notation only works in - unquoted - type literals:

• [...] is a PowerShell-specific notation for type literals (e.g., [System.DateTime]); .NET methods do not recognize this, although the string inside [...] (e.g., System.DateTime) uses a superset of the language-agnostic notation recognized by .NET methods such as System.Type.GetType() - see bottom section.

In your case, you don't even need explicit conversion of your type-name strings to [type] objects, because PowerShell implicitly performs this conversion when you call the ::Add() method. Therefore, the following is sufficient:

@{
   pxListObject = 'System.Collections.Generic.List[Object]'
   pxListString = 'System.Collections.Generic.List[String]'
   pxOrderedDictionary = 'System.Collections.Specialized.OrderedDictionary'
}.GetEnumerator() | ForEach-Object {

  # Calling ::Add() implicitly converts the type-name *string* to the required
  # [type] instance. 
  [powershell].Assembly.GetType('System.Management.Automation.TypeAccelerators')::Add(
    $_.Key,
    $_.Value
  )

}

Of course, you could have directly used type literals as your hashtable values:

# Note the use of [...] values (type literals) instead of strings.
@{
   pxListObject = [System.Collections.Generic.List[Object]]
   pxListString = [System.Collections.Generic.List[String]]
   pxOrderedDictionary = [System.Collections.Specialized.OrderedDictionary]
}.GetEnumerator() | ForEach-Object {
  [powershell].Assembly.GetType('System.Management.Automation.TypeAccelerators')::Add(
    $_.Key,
    $_.Value
  )

}

Caveat:

• Type System.Management.Automation.TypeAccelerators is non-public (hence the need to access it via reflection), and relying on non-public APIs is problematic.

• The alternative, available in PowerShell v5+, is to use the using namespace statement so you don't have to specify a full type name (see the bottom section for an example) - though note that it invariably makes all types in the specified namespace available by simple name (no namespace part).

---

As for what you tried:

$type = [PowerShell].Assembly.GetType('[System.Collections.ArrayList]') seems to work, in that it doesn't throw an exception.

• As stated, the outer [...] are not a part of the type name; however, removing them wouldn't be enough here, because the specified type isn't part of the same assembly as [PowerShell].

• Generally, System.Type.GetType() quietly returns $null if the specified type cannot be found; e.g.: [PowerShell].Assembly.GetType('DefinitelyNoSuchType')

[PowerShell].Assembly.GetType($pxAccelerators.$key) suggesting that the GetType() line is not actually producing a type.

The reason is that System.Type.GetType() doesn't recognize closed generic types such as System.Collections.Generic.List[String], because the underlying notation only supports open ones (such as System.Collections.Generic.List`1); the former notation is a PowerShell-specific extension to the notation - see the bottom section.

---

Converting type names stored in strings - without the enclosing [...] - to System.Type ([type]) objects:

Cast to [type]:

# Same as: [System.Collections.Generic.List[string]]; case does not matter.
[type] 'System.Collections.Generic.List[string]'

• Casting to [type] does more than calling System.Type.GetType(), because PowerShell's type-name strings support a superset of the latter's notation - see the bottom section.

• The above will cause a statement-terminating error (exception) if no such type is found (or the syntax is incorrect); note that only types among currently loaded assemblies are found.

• Alternatively, you can use 'System.Collections.Generic.List[string]' -as [type], as shown in Mathias R. Jessen's answer, which quietly returns $null if conversion to a type isn't possible; see -as, the conditional type conversion operator.

Note that both -as and -is also accept type-name strings as their RHS; e.g. 42 -is 'int' or '42' -as 'int'

Also, the New-Object cmdlet accepts strings as its -TypeName argument, so again the type-literal-enclosing [...] must not be used; e.g.,
New-Object -TypeName System.Text.UTF8Encoding

---

PowerShell's type-literal and type-name notation:

• A PowerShell type literal (e.g., [System.DateTime]) is a type name enclosed in [...], but the [ and ] are not part of the name.

  • Type literals are themselves instance of System.Type ([type]), or, more accurately, instances of the non-public [System.RuntimeType] type, which derives from System.Reflection.TypeInfo, which in turn derives from System.Type.

• Type-name strings can generally also be used where type literals (objects representing types) are accepted, with PowerShell converting to [type] implicitly, notably during parameter binding and on the RHS of -as, the conditional type-conversion operator and -is, the type(-inheritance) / interface test operator.

PowerShell implements a superset of the language-agnostic type-name notation used by .NET:

• The language-agnostic .NET notation, as used by System.Type.GetType(), for instance, is documented in Specifying fully qualified type names, and notably requires and includes:

  • Type names must be (at least) namespace-qualified names (e.g., System.Int32 rather than just Int32), and must be specified case-exactly by default; however, an overload with an ignoreCase parameter is available; names can optionally be assembly-qualified so as to also indicate the type's assembly of origin.

  • Suffix `<num> indicates the arity of generic types, i.e, the number (<num>) of type arguments the generic type requires (e.g, `1 for a type with one generic type parameter, such as System.Collections.Generic.List`1).

    • Using only a generic type's arity returns a generic type definition.

      • A generic type definition cannot be directly instantiated; instead, you must call the .MakeGenericType() instance method on the type object returned and pass (closed) type arguments for all generic type parameters, which then returns a closed [constructed] generic type, i.e. a concrete instantiation of the generic type definition from which instances can be constructed.

  • If you optionally follow the generic arity specifier with a list of type arguments to bind all type parameters defined by the generic type, a constructed generic type is directly returned; if all type arguments are closed themselves, transitively, i.e. have no unbound type parameters, if applicable, the type returned is a closed [constructed] type, which can directly be instantiated (its constructors can be called). The list of type arguments has the form [<type>] or, for multiple type arguments, [<type>, ...]; <type> references are subject to the same rules as the enclosing generic type's name, and may additionally be enclosed in [...] individually.

    • For instance, the following two type literals, which construct a closed Dictionary<TKey,TValue> type (to use C# notation for a change) with [string] keys and [int] values, are therefore equivalent:
      • System.Collections.Generic.Dictionary`2[System.String, System.Int32]
      • System.Collections.Generic.Dictionary`2[[System.String], [System.Int32]]

  • Suffixes [] / [,] indicate a single-dimensional / two-dimensional array; e.g., System.Int32[].

  • + is used to separate nested types from their containing class; e.g., System.Environment+SpecialFolder.

• The PowerShell-specific extensions are:

  • Name matching is invariably case-insensitive; e.g., type System.Text.UTF8Encoding can be targeted as [system.text.utf8encoding].

  • You may omit the System. component of the full name; e.g., [Text.UTF8Encoding]

  • You may use the names of PowerShell's type accelerators; e.g., [regex].

  • In PowerShell v5+ you can also use the using namespace statement so you don't have to specify a full type name:

    • E.g., placing using namespace System.Text at the top of a script or script module then allows you to refer to [System.Text.UTF8Encoding] as just [UTF8Encoding]

  • When you pass a list of generic type arguments, you may omit the type's arity specifier.

    • For instance, the following two type literals, which construct a closed Dictionary<TKey,TValue> type with [string] keys and [int] values, are therefore equivalent:
      • [System.Collections.Generic.Dictionary[string, int]]
      • [System.Collections.Generic.Dictionary`2[string, int]]

Answer 3

Example Use of Script Block to Solve the Problem

Maybe I was doing something wrong, but for some reason this dynamically built string didn't seem to like any of the official answers here:

[System.Collections.Generic.HashSet[System.Action[string, object]]]::new()

I gave up and did the following, perhaps this will be useful to someone else:

. ([ScriptBlock]::Create(@"
param(`$MyClass)
`$MyClass | Add-Member -NotePropertyName '$HashSetName' -NotePropertyValue ([System.Collections.Generic.HashSet$EventDef]::new())
"@)) -MyClass $this