Allow a simpler syntax to dynamically invoke generic methods at runtime

[Mafii]

I would like to propose a way to dynamically invoke generic methods.

Currently this can be done without problems:

public void Test<T>(T param1)
{
    Test2<T>(Param1);
}

public void Test2<T2>(T2 parameter)
{
  // use parameter
}

However, this is more complex (type of object param1 is not known at compiletime):

public void Test(object param1)
{
  var type = Param1.GetType();
  var methodTest2Info = typeof(ClassOfTest2).GetMethods().Single(method => method.Name == nameof(ClassOfTest2.Test2) && method.IsPublic && method.IsGenericMethod && !method.IsStatic);
  var methodWithGenericArguments = methodInfo.MakeGenericMethod(type);
  methodWithGenericArguments.Invoke(this, new object[] { param1 });
}

public void Test2<T2>(T2 parameter)
{
  // use parameter
}

If I understood correctly, these two codensippets are equally executed in the clr (ignoring reflection).

However, the second snippet is way less useful and harder to read.

I would propose the following syntax:

public void Test(object param1)
{
  // inside the <>, there has to be a expression that returns System.Type.
  Test2<param1.GetType()>(param1)
}

public void Test2<T2>(T2 parameter)
{
  // use parameter
}

[HaloFour]

In my opinion this is a concern for reflection and not one for the language. Such syntax would immediately disable the type safety provided by the language and by generics.

I do propose enhancements for reflection with generics, particular resolving generic methods: https://github.com/dotnet/corefx/issues/16567

If that proposal is adopted by the BCL then your code would resemble the following:

public void Test(object param1)
{
  var type = Param1.GetType();
  var methodTest2Info = typeof(ClassOfTest2).GetGenericMethod(
      nameof(ClassOfTest2.Test2),  // name of the method
      new Type[] { type } // the generic type arguments
  );
  methodTest2Info.Invoke(this, new object[] { param1 });
}

Which is much more inline with how normal methods are resolved/invoked via reflection.

[Mafii]

@HaloFour I really like that proposal, good work.

However, wouldn't that be solved by something like InfoOf (see https://github.com/Fody/InfoOf as an example)?

I know InfoOf has been deliberately rejected by the design team (I think I've read something from Eric Lippert about infoof we trust ;), but there could be something like methodInfoOf(ClassOfTest2.Test2<>) but that isn't really much more concise than your proposal.

[YaakovDavis]

As a side note, the fastereflect library is very helpful in such scenarios:
https://github.com/buunguyen/fasterflect

[svick]

Note that another possible workaround is to use dynamic:

public void Test(object param1)
{
    Test2((dynamic)param1);
}

public void Test2<T2>(T2 parameter)
{
    // use parameter
}

It has issues (the performance is going to be much worse than the generic version, though probably better than the reflection version), but it works and it's clear and short.

[Mafii]

@svick good point, however, Test2 will then be called with dynamic as a generic argument, no?

This has some unexpected side-effects when youre trying to do DbContext.Set<T> from EntityFramework for example - it will not work.

[svick]

@Mafii No, Test2 will be called with the runtime type of param1 as the generic argument.

I don't know how you would use the same approach for DbContext.Set<T>, since the generic overload of that method does not have a parameter, from which dynamic could infer the generic argument.