Generic version of System.Linq.Expressions.NewExpression

[Serg046]

When we deal with reflection/expressions/proxy we often see the methods like Activator.CreateInstance(Type type, params object[] args). But object[] args cannot be checked at compile-time. If there is no constructor that matches provided parameters (args) an exception will be thrown at run-time. It is a bad way in case when we clearly know which concrete parameters should be provided. For example proxy instance creation.

However we can check it by using LambdaExpression.
Demo:

static void Main(string[] args)
{
    //throw (NotSupportedException)System.Activator.CreateInstance(typeof(NotSupportedException), new object[] {"This argument cannot be checked at compile-time" });
    throw Activator.CreateInstance(() => new NotSupportedException("This is available but will be checked at run-time as well"));
}

static class Activator
{
    public static T CreateInstance<T>(Expression<Func<T>> constructorCall)
    {
        var newExpression = constructorCall.Body as NewExpression;
        if (newExpression == null)
            throw new ArgumentException("It must be NewExpression", nameof(constructorCall));
        var arguments = newExpression.Arguments.Select(expr => GetArgument((dynamic)expr)).ToArray();
        return (T)System.Activator.CreateInstance(typeof(NotSupportedException), arguments);
    }

    private static object GetArgument(ConstantExpression expression) => expression.Value;

    private static object GetArgument(UnaryExpression expression) => GetArgument((dynamic)expression.Operand);

    private static object GetArgument(Expression expression)
    {
        var convertExpr = Expression.Convert(expression, typeof(object));
        var lambda = Expression.Lambda<Func<object>>(convertExpr);
        return lambda.Compile().Invoke();
    }
}

But since we use LambdaExpression there is no way to check at compile-time whether constructor call is really provided. So the following code is also valid:

static void Main(string[] args)
{
    var exception = new NotSupportedException("This is also available at compile-time");
    throw Activator.CreateInstance(() => exception);
}

I would like to have NewExpression<T> to be able to pass compiler check if it will make sense for community.

static T CreateInstance<T>(NewExpression<T> constructorCall)

Thank you.

[svick]

What's special about NewExpression? Wouldn't you also want a generic version of all the other expression types?

Also, I don't understand what are you trying to achieve. How is Activator.CreateInstance(() => new NotSupportedException("…")) better than just new NotSupportedException("…")?

[JanEggers]

id rather like a extended generic constraint, right now there is just where T: new() for T must have default constructor. id like to see something like where T : new<int>() to enforce that T must have a constructor that takes an int. that way you can construct new T´s in a generic method without the need to use the activator just new T(i);

[svick]

@JanEggers That's dotnet/roslyn#2206 and dotnet/roslyn#14461 (which should probably be moved to this repo).

[Serg046]

@svick it was an example. It can be helpful for proxy instantiation and so on. Imagine that Activator.CreateInstance() looks like this:

public static T CreateInstance<T>(... args)
{
    return new ProxyGenerator().CreateClassProxy<T>(args);
}

So we are not able to call new NotSupportedException("…") directly. It will be called by proxy engine.

What's special about NewExpression?

It describes a constructor call. It can prove that provided lambda is constructor, not a field/variable or method/property call.

Wouldn't you also want a generic version of all the other expression types?

Why not but it is not required for the initial case.

[mattwar]

Is this a language feature request or a library feature request?

[svick]

@mattwar I think it's both. Implementing this would require adding a NewExpression<T> type to the library and also changing the language so that lambda expressions that contain new expression as their body can be converted to that type.

[mattwar]

Would you just add NewExpression<T>, what about AddExpression<T>, etc?

[Serg046]

The idea implies adding other expression types that can be created by lambda.
So I would like be able to do something like this:

NewExression<Func<StringBuilder>> ctorExpr = () => new StringBuilder("arg")

or

NewExression<StringBuilder> ctorExpr = () => new StringBuilder("arg")

So perhaps it will make sense to add NewExression<T>, MethodCallExpression<T> and MemberExpression<T> to the library and language but not sure about other expression types.

But consider MethodCallExpression<T>. What should it allow? Any lambda with method invocation? Can the ctor call be treated as method call? It can confuse a bit but can be helpful in case when we would like to filter variable/field/property access and so on. But again can the property access be treated as method (getter of property) call?

[devedse]

@svick, Shall I make a duplicate of my feature request in this repo? (dotnet/roslyn#14461)

[svick]

@devedse Yes, I think it makes sense to move it here, see dotnet/roslyn#18002. You can use a tool like Issue Mover for GitHub to help you with that.