InvokeMember inicia una ambigousMatchException

En este artículo se ayuda a resolver el problema en el que se puede producir un error al llamar al uso de la para invocar la versión no AmbigousMatchException genérica de la función System.Type.InvokeMember DefaultBinder Check .

Versión del producto original:   Microsoft .NET Framework 4.5
Número KB original:   2843607

Síntomas

Suponga que tiene una clase que tiene una sobrecarga genérica de un método, como se muestra en el ejemplo siguiente:

class Test
{
    public Boolean Check<T>(String Value)
    {
        return false;
    }
    public Boolean Check(String Value)
    {
        return true;
    }
}

Si llama al uso de la para invocar la versión no genérica de la función System.Type.InvokeMember DefaultBinder , se produce Check AmbigousMatchException una.

Causa

Si hay una sobrecarga genérica del método, no se puede diferenciar entre la versión genérica y no System.Type.DefaultBinder genérica de la función.

Solución

Cree un enlazador personalizado para devolver la sobrecarga no genérica del método y usarlo en la llamada, a continuación se muestra una implementación de InvokeMember ejemplo:

public class MyBinder : Binder
{
    public MyBinder()
        : base()
    { }

    public override FieldInfo BindToField(
        BindingFlags bindingAttr,
        FieldInfo[] match,
        object value,
        CultureInfo culture
        )
    {
        return System.Type.DefaultBinder.BindToField(bindingAttr, match, value, culture);
    }

    public override MethodBase BindToMethod(
        BindingFlags bindingAttr,
        MethodBase[] match,
        ref object[] args,
        ParameterModifier[] modifiers,
        CultureInfo culture,
        string[] names,
        out object state
        )
    {

        if (match == null)
            throw new ArgumentNullException();

        List<MethodBase> match2 = new List<MethodBase>();

        for (int i = 0; i < match.Length; i++)
        {
            if (!match[i].IsGenericMethod)
            {
                match2.Add(match[i]);
            }
        }

        return System.Type.DefaultBinder.BindToMethod(bindingAttr, match2.ToArray<MethodBase>(), ref args, modifiers, culture, names, out state);
    }
    public override object ChangeType(
        object value,
        Type myChangeType,
        CultureInfo culture
        )
    {

        return System.Type.DefaultBinder.ChangeType(value, myChangeType, culture);
    }
    public override void ReorderArgumentArray(
        ref object[] args,
        object state
        )
    {
        // Return the args that had been reordered by BindToMethod.
        System.Type.DefaultBinder.ReorderArgumentArray(ref args, state);
    }
    public override MethodBase SelectMethod(
        BindingFlags bindingAttr,
        MethodBase[] match,
        Type[] types,
        ParameterModifier[] modifiers
        )
    {
        return System.Type.DefaultBinder.SelectMethod(bindingAttr, match, types, modifiers);
    }
    public override PropertyInfo SelectProperty(
        BindingFlags bindingAttr,
        PropertyInfo[] match,
        Type returnType,
        Type[] indexes,
        ParameterModifier[] modifiers
        )
    {
        return System.Type.DefaultBinder.SelectProperty(bindingAttr, match, returnType, indexes, modifiers);
    }
}