Call Func<> with argument of type object

Question

I have (for instance) a Func<int, int> which I want to call as usual, except that the parameter is of type object rater than int. I only know the exact type of the Func and the argument at runtime, because the Func was created using Expression trees and is now accessed from a dynamic variable. (Simplified) code example:

using System.Linq.Expressions;

namespace FuncExample
{
    class Program
    {
        static void Main(string[] args)
        {
            object myFunc = CreateFunc(); // Could return something like
                                          // Func<int, int>, but may return a
                                          // completely different Func<> depending on
                                          // arguments etc.
            object result = getFromFunc(5, myFunc);
        }

        public static object CreateFunc()
        {
            LambdaExpression expr = Expression.Lambda(
                /*
                 * Create an expression
                 */
                );
            return expr.Compile();
        }

        public static object getFromFunc(object arg, object func)
        {
            dynamic dynFunc = func;
            return dynFunc(arg); // <------- Throws exception
        }
    }
}

How can I make the code convert arg into an integer or whatever Type the argument is? I tried making a generic method that casts the object to a certain type and then invoking it through reflection like this:

public static T asT<T>(object n)
{
    return (T)n;
}

for getFromFunc:

MethodInfo con = typeof(Program).GetMethod("asT").MakeGenericMethod(func.GetType().GetGenericArguments()[0]);
return dfunc(con.Invoke(null, new[] { value }));

But MethodInfo.Invoke also returns object. Any ideas on how to make sure the argument has the correct type?

@CharlesLambert On my system, I get "Delegate 'System.Func' has some invalid arguments". It uses `arg`'s static type, `object`, which is inappropriate for a function with a parameter of type `int`. — , May 09 '13 at 19:54

score 5 · Answer 1 · answered May 09 '13 at 20:47

All delegates derive from System.Delegate. You can use the System.Delegate.DynamicInvoke method to call a delegate whose type you don't know at compile time, similar to calling a method using MethodInfo.Invoke(). For example:

class Program
{
    public static Delegate CreateFunc()
    {
      return new Func<int, int>(x => x + 1);
    }

    public static void Main(string[] args)
    {
        var func = CreateFunc();
        object inArg = 42;
        object result = func.DynamicInvoke(inArg);
        Console.WriteLine(result);
    }
}

score 3 · Accepted Answer · answered May 09 '13 at 19:51

3

You're already using dynamic, so why not use dynamic?

return dynFunc((dynamic)arg);

This makes sure arg's runtime type gets used for determining whether it's an appropriate argument.

answered May 09 '13 at 19:51

Is `if (!(func.GetType().GetGenericArguments()[0] == arg.GetType()))` a valid way to check if its the wrong type? – May 09 '13 at 19:55
@MarkusHimmel That would throw an exception if `arg` is `null`, and would not perform any implicit conversions so would cause a false negative if, for example, the function takes an interface or base class and the argument is a derived class. I think you're better off not checking beforehand: you can reliably catch the exception and do something meaningful if the runtime detects that the argument has the wrong type. – May 09 '13 at 19:57

score 0 · Answer 3 · answered May 09 '13 at 19:59

0

What about something like this?

public static int Main(string[] args)
{
    // this could be any other lambda expression
    Func<object, object> unknownFunc = (a) => { return 13; };

    int result = (int) unknownFunc(13);
    Console.WriteLine(result);

    return 0;
}

answered May 09 '13 at 19:59

dinony

614
3
13

This doesn't work because I don't know at compile-time wether it will be an `int` or any other type. – May 09 '13 at 20:01

Call Func<> with argument of type object

3 Answers3