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?”

In an earlier post (http://www.leeholmes.com/blog/CreatingGenericTypesInPowerShell.aspx), 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?”

## 

param(

    $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

        if($type.IsGenericParameter)

        {

            $type = $genericTypes[$typeReplacementIndex]

            $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

        }

        $currentTypeIndex++

    }
    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

       ($method.IsGenericMethod))

    {

        $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

        }

    }

}
## Return an error if we couldn’t find that method

throw “Could not find method $methodName”