Archives for the Month of June, 2007

Invoking Generic Methods on Non-Generic Classes in PowerShell

A question recently came in asking, "How do you invoke a generic method on a non-generic class in PowerShell?"

[Edit: this "just works" in PowerShell V3]

PS C:\Users\Lee> add-type -Path C:\temp\generic.cs
PS C:\Users\Lee> $r = New-Object NonGenericClass
PS C:\Users\Lee> $r.GenericMethod("Hello", "Hello")
Hello Multi Generic World: True

In an earlier post (, we talked about how to create generic types in PowerShell, but classes can contain generic methods even when the classes themselves don't represent generic types.


It is possible to call the generic methods on this type of class, with the complexity of the solution depending on the complexity of the class.


Take, for example, the following class definition:


// csc /target:library GenericClass.cs
// [Reflection.Assembly]::LoadFile("c:\temp\GenericClass.dll")
using System;

public class NonGenericClass
public void SimpleGenericMethod<T>(T input)
Console.WriteLine("Hello Simple World: " + input);

public void GenericMethod<T>(T input)
Console.WriteLine("Hello World: " + input);

public void GenericMethod<T>(T input, int count)
for(int x = 0; x < count; x++)
Console.WriteLine("Hello Multi Partially Generic World: " + input);

public void GenericMethod<T,U>(T input, U secondInput) where T : IEquatable<T> where U : IEquatable<U>
Console.WriteLine("Hello Multi Generic World: " + input.Equals(secondInput));

public static void GenericStaticMethod<T>(T input)
Console.WriteLine("Hello Static World: " + input);


It gives an example of the breadth of the problem. We have a simple generic method, a generic method with overrides, and finally, a static generic method.


If you don't need to worry about naming conflicts (as in the SimpleGenericMethod and GenericStaticMethod methods,) the solution is just a few lines of code:


$nonGenericClass = New-Object NonGenericClass
$method = [NonGenericClass].GetMethod("SimpleGenericMethod")
$closedMethod = $method.MakeGenericMethod([string])
$closedMethod.Invoke($nonGenericClass, "Welcome!")


If you do have to worry about multiple methods with the same name, then the GetMethod() method can no longer help you. In that case, we need to call the GetMethods() method, and then find which method shares the proper parameter types.


To abstract all of this logic, use the following Invoke-GenericMethod script:


## Invoke-GenericMethod.ps1 
## Invoke a generic method on a non-generic type: 
## Usage: 
## ## Load the DLL that contains our class
## [Reflection.Assembly]::LoadFile("c:\temp\GenericClass.dll")
## ## Invoke a generic method on a non-generic instance
## $nonGenericClass = New-Object NonGenericClass
## Invoke-GenericMethod $nonGenericClass GenericMethod String "How are you?"
## ## Including one with multiple arguments
## Invoke-GenericMethod $nonGenericClass GenericMethod String ("How are you?",5)
## ## Ivoke a generic static method on a type
## Invoke-GenericMethod ([NonGenericClass]) GenericStaticMethod String "How are you?"

$instance = $(throw "Please provide an instance on which to invoke the generic method"),
[string] $methodName = $(throw "Please provide a method name to invoke"),
[string[]] $typeParameters = $(throw "Please specify the type parameters"),
[object[]] $methodParameters = $(throw "Please specify the method parameters")

## Determine if the types in $set1 match the types in $set2, replacing generic
## parameters in $set1 with the types in $genericTypes
function ParameterTypesMatch([type[]] $set1, [type[]] $set2, [type[]] $genericTypes)
$typeReplacementIndex = 0
$currentTypeIndex = 0

## Exit if the set lengths are different
if($set1.Count -ne $set2.Count)
return $false

## Go through each of the types in the first set
foreach($type in $set1)
## If it is a generic parameter, then replace it with a type from
## the $genericTypes list
$type = $genericTypes[$typeReplacementIndex]

## Check that the current type (i.e.: the original type, or replacement
## generic type) matches the type from $set2
if($type -ne $set2[$currentTypeIndex])
return $false

return $true

## Convert the type parameters into actual types
[type[]] $typedParameters = $typeParameters

## Determine the type that we will call the generic method on. Initially, assume
## that it is actually a type itself.
$type = $instance

## If it is not, then it is a real object, and we can call its GetType() method
if($instance -isnot "Type")
$type = $instance.GetType()

## Search for the method that:
## - has the same name
## - is public
## - is a generic method
## - has the same parameter types
foreach($method in $type.GetMethods())
# Write-Host $method.Name
if(($method.Name -eq $methodName) -and
($method.IsPublic) -and
$parameterTypes = @($method.GetParameters() | % { $_.ParameterType })
$methodParameterTypes = @($methodParameters | % { $_.GetType() })
if(ParameterTypesMatch $parameterTypes $methodParameterTypes $typedParameters)
## Create a closed representation of it
$newMethod = $method.MakeGenericMethod($typedParameters)

## Invoke the method
$newMethod.Invoke($instance, $methodParameters)


## Return an error if we couldn't find that method
throw "Could not find method $methodName"

Obfuscated PowerShell

For some reason, a surprisingly common (albeit half-joking) remark about PowerShell is that it hasn't "arrived" until you can write obfuscated one-liners like you do in C or Perl.

They may have missed Adam's obfuscated script (,) or this email quoting / wrapping one-liner:

While I normally try to clarify and educate, here's another script to make your eyes burn:

  ') ""'+        '"")[' + '($_*' + '3)..' +
'($_*'+        '3+2)' + '])""' + ' })"'|iex


[Edit: Added a missing something-or-other]