Dynamic Generics Proposal

[MiddleTommy]

In writing code that uses generics I always find it tedious and error prone to call generic methods and create generic classes when you don't know the type at compile time. I propose in a future version of C# that there is some syntactic sugar to make this easier.
For a class that looks like this
public class demo { string Foo<T>(); }
Currently you have to do something like this

`Example

        var obj = new demo(); 

        var type1 = typeof(Bar);

        var type = obj.GetType();

        MethodInfo methodinfo = type.GetMethod("Foo"); //Sometimes throws errors

        MethodInfo generic = methodinfo.MakeGenericMethod(type1);

        var value = generic.Invoke(obj, new object[]{});`

I would like to see it easier to do like this:

` Example

        var obj = new demo(); 

        var type1 = typeof(Bar);

        var value = obj.Foo<@type1>();

`
using the @ sign in front of the Type you could dynamically call generic methods or create Generic Classes while C# generates that messy, easy to get wrong reflection code for you (properly).

[MV10]

I imagine the Language Keepers will declare this too niche to consider, but the more I work with libraries, the more I find myself doing this same reflection-dance (and sort of hating it each time). However, I review and maintain a lot of code written by others, and I'm not sold on a easily-overlooked indicator like @, I think this needs to stand out more in the code. Maybe overload the existing dynamic keyword to make it crystal clear:

var value = obj.Foo<dynamic type1>();

[DavidArno]

I imagine the Language Keepers will declare this too niche to consider...

Over the years I've wanted to supply a type to a generic type/method via a variable on a number of occasions and haven't been able to. Invariably I've therefore resorted to reflection and/or passing it via a Type parameter or just given up and done it differently. Maybe it's niche, but maybe it's only niche because of the pain involved and only the dedicated/desperate therefore bother with it.

[orthoxerox]

This might be the first step towards first-class types.

[ViIvanov]

It is not possible to check constraints in this case, for example. It will not be obvious how the call will be made: through reflection, through the dynamic, or somehow else.

[MV10]

The dynamic language runtime can't do this today, so I don't see the ambiguity:

I read the proposal as a request to specifically create syntactic sugar around the reflection approach, and MakeGenericMethod will throw an ArgumentException if the supplied type does not satisfy any constraints (docs).

Hmm, did you mean my suggestion to overload dynamic might be confusing about the implementation? I guess I can see that argument. The proposed feature is very similar to the DLR's runtime deferral, although it isn't quite the same and presumably wouldn't actually involve the DLR. I just know how the language designers hate to add new keywords (with good reason), and I personally dislike "magic symbols" (unless they're heavily used like $ and @ for string literals).

We already have two divergent meanings for the using keyword, how about a third? 😁

[ViIvanov]

Thank you. The resulting code just looks like some analogue of dynamic code:

var instance = new Demo(); 
var argumentType = typeof(Bar);
var value = instance.Foo<@argumentType>(); // What the type of the "value"?

What if Demo declared as:

internal class Demo
{
   public T Foo<T>() => default(T);
}

It looks like, after applying @variableOfTypeType somewhere all code after it, related to this variable, has some statically undefined (object?) type. And the achievement seems not so big.

[LouisFr81]

You can't use @. It already is a valid character before an identifier.

[MV10]

@ViIvanov since the proposal is to wrap the longer reflection-based code, value is always an object (possibly boxing a value type), since that's what Invoke returns. Your example is exactly the same if you write object value instead of var value. For example, this works fine (the constraint and new() is needed, default is null and null.GetType() doesn't work):

class Foo
{
    public T Baz<T>() where T : new() => new T();
}

class Bar
{ }

var obj = new Foo();
var genericType = typeof(Bar);
MethodInfo methodInfo = obj.GetType().GetMethod("Baz");
MethodInfo genericMethod = methodInfo.MakeGenericMethod(genericType);

object value = genericMethod.Invoke(obj, new object[] { });

Bar cast = value as Bar;
Console.WriteLine(cast.GetType());

@LouisFr81 good catch, it seems the rest of us forgot the reserved-keyword / identifier-name disambiguation prefix. Hopefully there isn't much code out there using variable names like @object!

[MV10]

I should have thought of this earlier. A simple extension method is really all it takes:

public static class InvokeGenericExtension
{
    public static object InvokeGeneric(this object target, Type genericType, string methodName, params object[] methodParameters)
    {
        MethodInfo methodInfo = target.GetType().GetMethod("Baz");
        MethodInfo genericMethod = methodInfo.MakeGenericMethod(genericType);
        return genericMethod.Invoke(target, methodParameters);
    }
}

var value = new Foo().InvokeGeneric(typeof(Bar), "Baz");