CODEWITHSUNDEEP
c#reflectionsystem.reflection
Lukesta
Lukesta

Reputation: 33

Set parameter of any Func<>

I have an object of any of the func types func<>, Func<,>, func<,,> ... And I'd like to replace one of the input parameters with a constant value.

eg:

object SetParameter<T>(object function, int index, T value){
    //I don't know how to code this.
}

Func<int, String, String> function = (a, b) => a.ToString() + b;
object objectFunction = function;
object newFunction = SetParameter<int>(objectFunction, 0, 5);
// Here the new function should be a Func<String, String> which value "(b) => function(5, b)"

I already now how to get the type of the resulting function, but that does not really help me in implementing the desired behavior:

private Type GetNewFunctionType<T>(object originalFunction, int index, T value)
{
    Type genericType = originalFunction.GetType();

    if (genericType.IsGenericType)
    {
        var types = genericType.GetGenericArguments().ToList();
        types.RemoveAt(index);
        Type genericTypeDefinition = genericType.GetGenericTypeDefinition();
        return genericTypeDefinition.MakeGenericType(types.ToArray());
    }

    throw new InvalidOperationException($"{nameof(originalFunction)} must be a generic type");
}

Upvotes: 1

Views: 303

Answers (2)

weichch
weichch

Reputation: 10035

Just in case you need to use expression tree to build the function:

object SetParameter<T>(object function, int index, T value)
{
    var parameterTypes = function.GetType().GetGenericArguments();

    // Skip where i == index
    var newFuncParameterTypes = parameterTypes.SkipWhile((_, i) => i == index).ToArray();

    // Let's assume function is Fun<,,> to make this example simple :)
    var newFuncType = typeof(Func<,>).MakeGenericType(newFuncParameterTypes);

    // Now build a new function using expression tree.
    var methodCallParameterTypes = parameterTypes.Reverse().Skip(1).Reverse().ToArray();
    var methodCallParameters = methodCallParameterTypes.Select(
        (t, i) => i == index
            ? (Expression)Expression.Constant(value, typeof(T))
            : Expression.Parameter(t, "b")
        ).ToArray();

    // func.Invoke(5, b)
    var callFunction = Expression.Invoke(
        Expression.Constant(function),
        methodCallParameters);

    // b => func.Invoke(5, b)
    var newFunc = Expression.Lambda(
        newFuncType,
        callFunction,
        methodCallParameters.OfType<ParameterExpression>()
    ).Compile();

    return newFunc;
}

To use this:

Func<int, string, string> func = (a, b) => a.ToString() + b;

var newFunc = (Func<string, string>)SetParameter<int>(func, 0, 5);

// Output: 5b
Console.WriteLine(newFunc("b"));

Upvotes: 0

Xerillio
Xerillio

Reputation: 5261

It's not quite clear what the purpose of your conversion is for, but wouldn't it be easier to avoid all the reflection. E.g.:

Func<int, string, string> func3 = (a, b) => a.ToString() + b;

Func<string, string> func3withConst = (b) => func3(10, b);

Since you are talking about a very limited scope (supporting just Func<TReturn>, Func<T1, TReturn> and Func<T1, T2, TReturn>) doing this through reflection is much more error prone and harder to read.

Upvotes: 1

Related Questions