[API Proposal]: Add invoker classes for fast invoke APIs

[steveharter]

Background and motivation

This will add "fast invoke" capability, allowing for up to 2x CPU improvement and eliminating the object[] parameters alloc for some scenarios. The existing MethodBase.Invoke(...) will also leverage this when possible. It is part of a larger goal to reduce usage of Reflection.Emit where feasible, which means performance is critical since Emit was originally used over Invoke because of performance.

API Proposal

New types:

namespace System.Reflection
{
    public abstract class MethodBaseInvoker
    { 
        internal MethodBaseInvoker(); // Or any internal ctor that removes the default ctor preventing external derivations.
    }

    public sealed class ConstructorInvoker : MethodBaseInvoker
    {
        // The caller is assumed to cache the invoker.
        public static ConstructorInvoker Create(ConstructorInfo constructor);

        internal ConstructorInvoker(); // Or any internal ctor that removes the default ctor preventing default constructor.

        // All methods have the same semantics as 'MethodBase.Invoke(...)' for validation and defaulting with the
        // possible exception (TBD) of supporting 'Type.Missing'; the user would need to use 'ParameterInfo.DefaultValue'.

        // This supports copy-back for ref\out args like 'MethodBase.Invoke(...)'.
        public object? Invoke(Span<object?> arguments);

        public object? Invoke();

        // These cannot support copy-back; adding 'ref' modifier is not desired here.
        public object? Invoke(object? arg1);
        public object? Invoke(object? arg1, object? arg2);
        public object? Invoke(object? arg1, object? arg2, object? arg3);
        public object? Invoke(object? arg1, object? arg2, object? arg3, object? arg4);
    }

    public sealed class MethodInvoker : MethodBaseInvoker
    {
        public static MethodInvoker Create(MethodInfo method);

        internal MethodInvoker(); // Or any internal ctor that removes the default ctor preventing default constructor.

        public object? Invoke(object? obj, Span<object?> arguments);
        public object? Invoke(object? obj);
        public object? Invoke(object? obj, object? arg1);
        public object? Invoke(object? obj, object? arg1, object? arg2);
        public object? Invoke(object? obj, object? arg1, object? arg2, object? arg3);
        public object? Invoke(object? obj, object? arg1, object? arg2, object? arg3, object? arg4);
    }
}

API Usage

Simple replacement for MethodBase.Invoke:

MethodInfo method = typeof(TestClass).GetMethod(nameof(TestClass.Method1))!;
MethodInvoker cachedInvoker = MethodInvoker.Create(method);

TestClass obj = new();

// Invoke the method without having to create an `object[]` to contain the args.
cachedInvoker.Invoke(obj, 42);

public class TestClass
{
    public void Method1(int i) { }
}

For high-performance APIs such as DI's ActivatorUtiliities.CreateFactory():

private static object CallConstructor(ConstructorInvoker cachedInvoker, Span<object> args)
{
    // 'args' is not the exact set of parameters; we have "Transform()" logic to determine
    if (args.Length <= 4)
    {
        // Fast logic to avoid object[] allocation
        switch (args.Length)
        {
            case 0:
                return cachedInvoker.Invoke();
            case 1:
                return cachedInvoker.Invoke(args[0].Transform());
            case 2:
                return cachedInvoker.Invoke(args[0].Transform(), args[1].Transform());
            case 3:
                return cachedInvoker.Invoke(args[0].Transform(), args[1].Transform(), args[2].Transform());
            case 4:
                return cachedInvoker.Invoke(args[0].Transform(), args[1].Transform(), args[2].Transform(), args[3].Transform());
        }
    }
    else
    {
        Span<object> copyOfArgs = new object[args.Length];
        for (int i = 0; i < args.Length; i++)
        {
            copyOfArgs[i] = args[i].Transform();
        }
        return cachedInvoker.Invoke(copyOfArgs);
    }
}

private static object Transform(this object obj)
{
    object newObj = // Assume special logic here such as defaulting or conversion of parameters.
    return newObj;
}

Validation

Alternative Designs

Note that these proposed invoker classes already exist internally.

Support for byref-like types is covered here which has been prototyped successfully. However, the performance of that is not ideal when only System.Object is necessary which is the case for DI's CreateFactory which calls constructors with user-specified object - based args.

Tagging subscribers to this area: @dotnet/area-system-reflection
See info in area-owners.md if you want to be subscribed.

Issue Details

---

Background and motivation

(placeholder)

API Proposal

(placeholder)

API Usage

(placeholder)

Alternative Designs

(placeholder)

Risks

(placeholder)

Author:	steveharter
Assignees:	-
Labels:	api-needs-work, area-System.Reflection
Milestone:	8.0.0

[jkotas]

• The factory method can be on the MethodInvoker/ConstructorInvoke methods. There is no reasonable way for non-runtime MethodInfos to provide implementation for this since the Invoker types are sealed.
• We may want to have separate types for invoking construtors vs. invoking methods. It would allow us to avoid some overhead in the AOT scenarios:

public class MethodInvoker
{
        public ConstructorInvoker Create(MethodBase info);
...
}

public class ConstructorInvoker
{
        public ConstructorInvoker Create(ConstructorInfo info);
...
        // We do not need this ptr for these.
        public object? Invoke(Span<object?> arguments);

        public object? Invoke(object? arg1);
        public object? Invoke(object? arg1, object? arg2);
        public object? Invoke(object? arg1, object? arg2, object? arg3);
        public object? Invoke(object? arg1, object? arg2, object? arg3, object? arg4);
}

[teo-tsirpanis]

How about adding extension methods to MethodInfo and ConstructorInfo instead of dedicated invoker classes?

[jkotas]

How about adding extension methods to MethodInfo and ConstructorInfo instead of dedicated invoker classes?

The extension methods would have to first check for null "this" and then cast the MethodInfo to RuntimeMethodInfo. It is unnecessary overhead. The only reason why we are adding this is to squeeze performance out of reflection invoke.

[Joe4evr]

public sealed class ConstructorInvoker
{
    public static ConstructorInvoker Create(this ConstructorInfo constructor);
}

Unless I'm unaware of a recent language change, extension methods can only exist in static classes, so this won't work.

[teo-tsirpanis]

Guess it's a typo, an extension method for Create wouldn't make sense.

[bartonjs]

Video

• There was a question of why the Invoke methods took a Span instead of ReadOnlySpan. The answer was for ref/out semantics.
• The base class is an implementation detail that shouldn't leak into the ref. It should be removed.
• For MethodInvoker.Invoke, we checked that obj is the consistent name for the target/instance parameter.
• We discussed the number of overloads/number of argN options, and felt that 3 or 4 are both OK (but that we really want params Span)
• If there are places in reflection that use arg0..argN instead of arg1..argN, we should change the indexing here to match.
• Create vs .ctor came up, and Create seems justified (e.g. future caching opportunities)

namespace System.Reflection
{
    public sealed class ConstructorInvoker
    {
        public static ConstructorInvoker Create(ConstructorInfo constructor);

        private ConstructorInvoker();

        public object? Invoke();
        public object? Invoke(object? arg1);
        public object? Invoke(object? arg1, object? arg2);
        public object? Invoke(object? arg1, object? arg2, object? arg3);
        public object? Invoke(object? arg1, object? arg2, object? arg3, object? arg4);
        public object? Invoke(Span<object?> arguments);
    }

    public sealed class MethodInvoker
    {
        public static MethodInvoker Create(MethodInfo method);

        private MethodInvoker();

        public object? Invoke(object? obj);
        public object? Invoke(object? obj, object? arg1);
        public object? Invoke(object? obj, object? arg1, object? arg2);
        public object? Invoke(object? obj, object? arg1, object? arg2, object? arg3);
        public object? Invoke(object? obj, object? arg1, object? arg2, object? arg3, object? arg4);
        public object? Invoke(object? obj, Span<object?> arguments);
    }
}