Dynamically set Func<> types

c#, func, types

Solution

Now that you showed what you really want, the answer is much more simple: As you are apparently only interested in the return value of that expression, you could change your code to this:

Type t = typeof(StavkaDokumenta).GetProperty(pd.Polje).PropertyType;
ParameterExpression pe = Expression.Parameter(typeof(StavkaDokumenta), "stavka");
Expression expr = Expressions.ResolveCompleteExpression(pe, pd.Expression);
Expression final = Expression.Convert(expr, t);

if (t == typeof(string))
{
    var lambda = Expression.Lambda<Func<string>>(final, null);
    o = lambda.Compile().Invoke();
}
else
{
    var lambda = Expression.Lambda(final, pe);
    o = lambda.Compile().DynamicInvoke(stavka);
}

Old answer:

You can use generics and implicit conversion to `Func<T>` to achieve this:

Func<T> GetFunc<T>(Func<T> func)
{
    return func;
}

Call it with a method group like so:

var foo = GetFunc(SomeMethod);

This assumes that `SomeMethod` looks like this:

decimal SomeMethod()
{
    // ...
}

`foo` will be of type `Func<decimal>`. If the return type of `SomeMethod` would be a `string`, the type of `foo` would be `Func<string>`.

What happens in this code is the following:

The parameter that is passed to `GetFunc` is a so-called "method group" and not a variable of type `Func<T>`. However, there exists an implicit conversion from a method group to a variable of `Func<T>`:

Func<decimal> func = SomeMethod; // an implicit conversion happens here

That implicit conversion is exactly what is happening here: Before `GetFunc` is even called, the method group `SomeMethod` is converted the a variable of type `Func<T>`. The concrete type used for `T` is additionally inferred by the compiler based on the return type of the method `SomeMethod()`. Our goal was to create an instance of `Func<T>` based on our method group. And because that already happens in the conversion of the parameter before the method is even called, we simply return that created instance from the method.

Problem

Original source