Question

hy there!

given is this class:

public static class FooClass<TFoo>
{
    public static TFoo FooMethod(object source)
    {
        // implementation goes here
    }
}

now i want to create this class:

public static class FooClass
{
    public static object FooMethod(object source, Type fooType)
    {
        var classType = typeof (FooClass<>).MakeGenericType(fooType);
        var methodInfo = classType.GetMethod("FooMethod", new[]
        {
            typeof (object)
        });
        // WHAT NOW?!
    }
}

also to mention:

• there are overloads of FooMethod in FooClass<TFoo>, but i only want to give access to mentioned overload (signature is matching – except paramterNames)
• returnType object would be succifient
• i cannot make FooMethod in FooClass generic – it should be an “oldstyle” interface, as it will be used from reflection-code

Answer 1

Something like:

public static class Foo
{
    public static object FooMethod(object source, Type fooType)
    {
        return typeof(Foo<>).MakeGenericType(fooType)
            .GetMethod("FooMethod").Invoke(null, new object[] { source });
    }
}

however – this reflection can be slow in a tight loop; if you are doing this lots, I would be tempted to reverse the dependency, so the generic code calls into the non-generic code:

public static class Foo<TFoo>
{
    public static TFoo FooMethod(object source)
    {
        return (TFoo)Foo.FooMethod(source, typeof(TFoo));
    }
}

(with the implementation in the non-generic version)