Y at-il un System.Reflection.Binder (.NET) qui se lie à des méthodes génériques?

Question

Le code suivant F# échoue parce que Type.DefaultBinder ne veut pas se lier à la méthode Id générique. Y at-il une Binder alternative qui ferait cela?

open System
open System.Reflection

type Foo() =
    member this.Id<'T>(x: 'T) : 'T = x //'

typeof<Foo>.InvokeMember (
    "F", 
    BindingFlags.InvokeMethod,
    Type.DefaultBinder,
    (new Foo()),
    [| box "test" |]
)

Voici équivalent C #:

using System;
using System.Reflection;

public class Foo {

    T Id<T>(T x) { 
        return x;
    }

    static void Main() {
        typeof(Foo).InvokeMember
        (
         "F",
         BindingFlags.InvokeMethod,
         Type.DefaultBinder,
         (new Foo()),
         new object[] {"test"}
        );
    }
}

Answer 1

La note sous la rubrique "Remarques" à la page InvokeMember indique que InvokeMember ne peut pas être utilisé pour invoquer une méthode générique. On peut supposer que ce lié au fait que vous ne pouvez pas utiliser typeof<Foo>.GetMethod("Id").Invoke(...) non plus, puisque vous devez spécifier un paramètre générique en quelque sorte.

Par contre, il semble que vous pouvez probablement pirater quelque chose ensemble qui a un coup de feu à travailler:

type MyBinder() =
  inherit System.Reflection.Binder() with
  let bnd = System.Type.DefaultBinder
  override x.SelectProperty(a,b,c,d,e) = bnd.SelectProperty(a,b,c,d,e)
  override x.ChangeType(a,b,c) = bnd.ChangeType(a,b,c)
  override x.BindToField(a,b,c,d) = bnd.BindToField(a,b,c,d)
  override x.ReorderArgumentArray(a,b) = bnd.ReorderArgumentArray(&a,b)
  override x.SelectMethod(a,b,c,d) = bnd.SelectMethod(a,b,c,d)
  override x.BindToMethod(a,meths,args,b,c,d,e) = 
    try 
      bnd.BindToMethod(a,meths,&args,b,c,d,&e)
    with _ ->
      let [| meth |],[| arg |] = meths,args
      upcast (meth :?> System.Reflection.MethodInfo).MakeGenericMethod([| arg.GetType() |])

Ce ne traite que des méthodes génériques non surchargées avec un seul argument, mais vous pouvez tenter de le rendre plus robuste. Je ne serais pas surpris si cette mise en œuvre de BindToMethod brise toutes sortes d'invariants attendus, cependant, car il renvoie une méthode qui n'a pas été adoptée en tant que candidat.

Answer 2

Cela ne répond pas directement à votre question, mais si votre but ultime est juste d'appeler la méthode, vous pouvez le faire par exemple.

open System
open System.Reflection

type Foo() =
    member this.Id<'T>(x: 'T) : 'T = x    // '

let ms = typeof<Foo>.GetMethods() 
      |> Array.filter (fun m -> m.Name="Id" && m.GetGenericArguments().Length=1)
assert( ms.Length = 1 )
let m = ms.[0]
let r = m.MakeGenericMethod([|typeof<string>|]).Invoke(new Foo(),[|box "test"|])
printfn "%A" r    

Answer 3

Voici une solution spécifique C # pour trouver une méthode d'extension générique et il pourrait être modifié pour mettre en œuvre un liant. Pour votre information: mes besoins où simples et ne sont pas liés les performances, je viens juste besoin d'une solution de travail ainsi, sur cette note, je suis conscient que cela doit accordage important et peut avoir des lacunes. Tout commentaire est bien cependant.

J'espère que cela aide votre problème

    private MethodInfo FindExtensionMethod(Type instancetype, string methodName, Expression[] args)
    {
        Type[] parametertypes = Enumerable.Repeat(instancetype, 1).Concat(args.Cast<ConstantExpression>().Select(a => a.Value.GetType())).ToArray();
        var methods = AppDomain.CurrentDomain.GetAssemblies()
            .SelectMany(a => a.GetTypes().Where(t => t.IsSealed && !t.IsGenericType && !t.IsNested))
            .SelectMany(t => t.GetMethods(BindingFlags.Static | BindingFlags.Public)
                .Where(m => m.IsDefined(typeof(ExtensionAttribute), false)
                    && m.Name == methodName
                    && CanBeInvokedWith(m, parametertypes))
                .Select(m => EnsureInvokableMethodFor(m, parametertypes)))
            .ToList();

        return methods.FirstOrDefault();
    }

    private MethodInfo EnsureInvokableMethodFor(MethodInfo method, Type[] parameterTypes)
    {
        if (method.ContainsGenericParameters)
        {
            var genericparams = GetGenericParametersFor(method, parameterTypes).ToArray();
            MethodInfo nongenric = method.MakeGenericMethod(genericparams);
            return nongenric;
        }
        else
            return method;
    }

    private IEnumerable<Type> GetGenericParametersFor(MethodInfo method, Type[] parameterTypes)
    {
        IDictionary<int, Type> args = new Dictionary<int, Type>();
        List<Type> genargs = new List<Type>(method.GetGenericArguments());
        int i = 0;
        foreach (var parameter in method.GetParameters())
        {
            if (parameter.ParameterType.IsGenericParameter)
            {
                AddGenArgs(args,
                    genargs.IndexOf(parameter.ParameterType),
                    parameterTypes[i]);
            }
            else
            {
                if (parameter.ParameterType.IsGenericType)
                {
                    int j = 0;
                    foreach (Type genarg in parameter.ParameterType.GetGenericArguments())
                    {
                        if (genarg.IsGenericParameter)
                        {
                            AddGenArgs(args,
                                genargs.IndexOf(genarg),
                                parameterTypes[i].GetGenericArguments()[j]);
                        }
                        j++;
                    }
                }
            }
            i++;
        }

        return args.Values;
    }

    private static void AddGenArgs(IDictionary<int, Type> args, int argindex, Type arg)
    {
        if (args.ContainsKey(argindex))
        {
            if (args[argindex] != arg)
                throw new ArgumentOutOfRangeException();
        }
        else
            args[argindex] = arg;
    }

    private bool CanBeInvokedWith(MethodInfo method, Type[] parametertypes)
    {
        var parameters = method.GetParameters();
        if (parameters.Length != parametertypes.Length)
            return false;
        int i = 0;
        return parameters.All(p => CanBeAssignedFrom(p.ParameterType, parametertypes[i++]));
    }

    private bool CanBeAssignedFrom(Type paramType, Type argType)
    {
        if (paramType.IsGenericType)
        {
            if (argType.IsGenericType)
            {
                if (paramType.GetGenericTypeDefinition() == argType.GetGenericTypeDefinition())
                {
                    return GenericArgsAreCompatible(
                        paramType.GetGenericArguments(),
                        argType.GetGenericArguments());

                }
                else
                    return false;
            }
            else
                return false;
        }
        else
        {
            if (paramType.IsGenericParameter)
                return true;
            else
                return paramType.IsAssignableFrom(argType);
        }
    }

    private bool GenericArgsAreCompatible(Type[] paramArgs, Type[] argArgs)
    {
        if (paramArgs.Length != argArgs.Length)
            return false;

        int i = 0;
        return paramArgs.All(p => TypesAreCompatible(p, argArgs[i++]));
    }

    private bool TypesAreCompatible(Type paramArg, Type argArg)
    {
        if (paramArg.IsGenericParameter)
            return true;
        else
            return paramArg == argArg;
    }