Dynamically set Func<> types

Question

is there any way to set Func<> type arguments dynamically, so i don't have to use endless if statements?

Something like:

Type t = Type.GetType("System.Decimal");
Func<t> foo = new Func<t>(some_function);

Instead of:

Func<Decimal> foo = new Func<Decimal>(some_function);

UPDATE:

Here's a snippet from my code:

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(decimal))
{
    var lambda = Expression.Lambda<Func<StavkaDokumenta, decimal>>(final, pe);
    o = lambda.Compile().Invoke(stavka);
}
if (t == typeof(decimal?))
{
    var lambda = Expression.Lambda<Func<StavkaDokumenta, decimal?>>(final, pe);
    o = lambda.Compile().Invoke(stavka);
}
else if (t == typeof(int))
{
    var lambda = Expression.Lambda<Func<StavkaDokumenta, int>>(final, pe);
    o = lambda.Compile().Invoke(stavka);
}
else if (t == typeof(int?))
{
    var lambda = Expression.Lambda<Func<StavkaDokumenta, int?>>(final, pe);
    o = lambda.Compile().Invoke(stavka);
}
else if (t == typeof(string))
{
    var lambda = Expression.Lambda<Func<string>>(final, null);
    o = lambda.Compile().Invoke();
}

pd.Polje is string - name of a property inside "StavkaDokumenta" class. pd.Expression is string expression that must evaluate to type of Polje. stavka is an instance of StavkaDokumenta.

If you are using endless ifs, maybe there is something about your current approach that could be improved? I would at least consider it. — Botz3000, Apr 16 '12 at 14:45
Could you provide an example of an endless if chain that you're trying to resolve? — GregC, Apr 16 '12 at 14:45
If you're using endless `xxx is SomeType`, there is probably something wrong with your design. — Eric J., Apr 16 '12 at 14:45
How does changing the type to a type variable involve if statements? — Bali C, Apr 16 '12 at 14:48
@BaliC: I think he is doing something along the lines of this: `if(t == typeof(decimal)) foo = new Func(some_function); else if(t == typeof(string)) foo = new Func(some_function);` — Daniel Hilgarth, Apr 16 '12 at 14:49
@DanielHilgarth, btw what type of `foo` in your last example? — Sergey Berezovskiy, Apr 16 '12 at 14:56
Can you please describe in one or two sentences what the snippet you just added to your question achieves? In other words, how would the lambda expression look like if this wouldn't be dynamic? — Daniel Hilgarth, Apr 16 '12 at 15:26

Daniel Hilgarth · Accepted Answer · 2012-04-16T15:36:37.200

9

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.

edited Apr 16 '12 at 15:36

answered Apr 16 '12 at 14:47

Daniel Hilgarth

171,043
40
335
443

I'm sorry, but I don't follow. Your method `GetFunc` is effectively doing nothing. It returns the parameter as the same type it began. – Yuck Apr 16 '12 at 14:49
@Yuck: The magic is happening in the call itself because there exists an implicit conversion from a method group (`SomeMethod`) to a variable of type `Func`. – Daniel Hilgarth Apr 16 '12 at 14:50
I'll try it now Daniel, but I think that will do the trick. I was stuck and was starting to settle with ifs... – Milos Mijatovic Apr 16 '12 at 15:01
@DanielHilgarth how it will help to avoid `if` checks? E.g. `if(t == typeof(decimal)) foo = GetFunc(decimal_function); else if(t == typeof(string)) foo = GetFunc(string_function);` and what type of foo should be in this example to compile? – Sergey Berezovskiy Apr 16 '12 at 15:12
@lazyberezovsky: I don't understand the question. The code you copied from my comment doesn't compile in its form, it was meant as pseudo code. – Daniel Hilgarth Apr 16 '12 at 15:17
@MilosMijatovic: You shouldn't answer your question, if you have another question. Instead, **update** your question please. – Daniel Hilgarth Apr 16 '12 at 15:18
@MilosMijatovic: What type are `final` and `pe`? How are they initialized? – Daniel Hilgarth Apr 16 '12 at 15:19
@DanielHilgarth, thats exactly why I'm asking how your GetFunc method could be used. I just don't understand how it could help to remove endless `if` statements. – Sergey Berezovskiy Apr 16 '12 at 15:23
@lazyberezovsky: To be honest, now that I think about it, I can't seem to find a case where it would be useful, except when using `dynamic`. – Daniel Hilgarth Apr 16 '12 at 15:39
Thanks, Daniel. That was it! Great! – Milos Mijatovic Apr 16 '12 at 15:44
2

Where is 'Expressions.ResolveCompleteExpression' method? I don't see it. – Craig Boland May 14 '12 at 19:11
@CraigBoland: I assume it is a method the OP created. – Daniel Hilgarth May 15 '12 at 07:09

Dynamically set Func<> types

1 Answers1