Dla niektórych wymyślnych rzeczy refleksyjnych, mam funkcję typu Func i muszę przekazać ją do funkcji, która akceptuje typ Func, gdzie T nie jest znane do czasu uruchomienia. Na przykład:

public bool MyOperation(Func<string,bool> op) {
  return _myValues.Any(op);
}

public static bool InvokeOperationMethod(MethodInfo info, object obj,Func<object,bool> opAsObject)
{
   info.Invoke(obj, opAsObject);
}

Problem polega na tym, że skoro mam lambdę słabszego typu, nie mogę go przekazać jako argumentu silniejszego typu. Próbowałem więc stworzyć pomocnika, który utworzy funkcję, która przekształca lambdę słabszego typu w silniejszy. Na przykład mógłbym zadzwonić

var converter = CreateConverter(typeof(string));
Func<object,bool> asObject = o => o.ToString() == "a string"; //Dump example
Func<string,bool> asString = (Func<string,bool>)converter(asObject);
Assert.IsTrue(asInt("a string"));

Oczywiście w rzeczywistym kodzie typ docelowy nie jest znany do czasu uruchomienia, a rzeczywisty predykat nie jest jakimś banalnym testem.

To jest moja próba:

/// <summary>
/// Converts a predicate of Func<object,bool> to
/// Func<Type,bool> of the given type.
/// </summary>
/// <param name="destType">Type of the dest.</param>
/// <param name="predicate">The predicate.</param>
/// <returns></returns>
public static TransformPredicate CreateConverter(Type destType)
{
    // This essentially creates the following lambda, but uses destType instead of T
    // private static Func<Func<object, bool>, Func<T, bool>> Transform<T>()
    // { 
    //     return (Func<object,bool> input) => ((T x) => input(x));
    // }
    var input = Expression.Parameter(typeof(Func<object, bool>), "input");

    var x = Expression.Parameter(destType, "x");
    var convert = Expression.Convert(x, typeof(object));
    var callInputOnX = Expression.Invoke(input, convert);
    var body2 = Expression.Lambda(callInputOnX, x);
    var body1 = Expression.Lambda(typeof(TransformPredicate),body2, input);
    return (TransformPredicate) body1.Compile();
}

public delegate object TransformPredicate(Func<object,bool> weak);

To działa dobrze, z wyjątkiem tego, że działa bardzo powoli, ponieważ niejawnie wywołuje CreateDelegate przy każdym wywołaniu. Próbowałem więc zadzwonić do CreateDelegate siebie, dodając:

var destFunc = typeof(Func<,>).MakeGenericType(destType, typeof(bool));
var endType = typeof(Func<,>).MakeGenericType(typeof(Func<object, bool>), destFunc);
return (TransformPredicate)compiled.Method.CreateDelegate(endType);

Powoduje to błąd:

System.NotSupportedException: klasy pochodne muszą zapewniać i implementować.

Jakieś pomysły, jak mogę zadzwonić do CreateDelegate?