FUNC<>参数数量未知

时间:2014-04-03 09:59:05

标签: c# .net generics functional-programming clr

考虑以下伪代码:

    TResult Foo<TResult>(Func<T1, T2,...,Tn, TResult> f, params object[] args)
    {
        TResult result = f(args);
        return result;
    }

该函数接受具有未知数量的泛型参数的Func<>和相应参数的列表。是否可以用C#编写?如何定义和调用Foo?如何将args传递给f

6 个答案:

答案 0 :(得分:13)

那是不可能的。最好的情况是,您可以拥有一个也可以获取可变数量参数的委托,然后让委托解析参数

TResult Foo<TResult>(Func<object[], TResult> f, params object[] args)
{
    TResult result = f(args);
    return result;
}


Foo<int>(args =>
{
    var name = args[0] as string;
    var age = (int) args[1];

    //...

    return age;
}, arg1, arg2, arg3);

答案 1 :(得分:9)

您可以将DelegateDynamicInvoke一起使用。

有了这个,你就不需要在object[]中处理f

TResult Foo<TResult>(Delegate f, params object[] args)
{
    var result = f.DynamicInvoke(args);
    return (TResult)Convert.ChangeType(result, typeof(TResult));
}

用法:

Func<string, int, bool, bool> f = (name, age, active) =>
{
    if (name == "Jon" && age == 40 && active)
    {
        return true;
    }
    return false;
}; 

Foo<bool>(f,"Jon", 40, true);

我创建了一个小提琴,展示了一些例子:https://dotnetfiddle.net/LdmOqo

注意:

如果您想使用method group,则需要使用明确的转换为Func

public static bool Method(string name, int age)
{
    ...
}
var method = (Func<string, int, bool>)Method;
Foo<bool>(method, "Jon", 40);

小提琴:https://dotnetfiddle.net/3ZPLsY

答案 2 :(得分:2)

使用lambda表达式可以变得很容易:

TResult Foo<Tresult>(Func<TResult> f)
{
  TResult result = f();
  return result;
}

然后用法就像:

var result = Foo<int>(() => method(arg1, arg2, arg3));

method可以是返回int的任意方法。

这样,您可以直接通过lambda传递任意数量的任何参数。

答案 3 :(得分:0)

在某些情况下,你可能会躲过这样的伎俩:

public static class MyClass
{
    private static T CommonWorkMethod<T>(Func<T> wishMultipleArgsFunc)
    {
        // ... do common preparation
        T returnValue = wishMultipleArgsFunc();
        // ... do common cleanup
        return returnValue;
    }

    public static int DoCommonWorkNoParams() => CommonWorkMethod<int>(ProduceIntWithNoParams);
    public static long DoCommonWorkWithLong(long p1) => CommonWorkMethod<long>(() => ProcessOneLong(p1));
    public static string DoCommonWorkWith2Params(int p1, long p2) => CommonWorkMethod<string>(() => ConvertToCollatedString(p1, p2));

    private static int ProduceIntWithNoParams() { return 5; }
}

答案 4 :(得分:0)

您可以尝试类似于我在此处发布的内容:https://stackoverflow.com/a/47556051/4681344

它将允许任意数量的参数,并强制执行其类型。

public delegate T ParamsAction<T>(params object[] args);

TResult Foo<TResult>(ParamsAction<TResult> f)
{
    TResult result = f();
    return TResult;
}

称呼它,只是......

Foo(args => MethodToCallback("Bar", 123));

答案 5 :(得分:-1)

尽管并不是真正要问的问题,但是一个简单的解决方法是定义几个具有不同数量类型参数的Foo方法。 具有超过6个参数的功能并不常见,因此可以定义以下方法并在保持类型安全的同时摆脱几乎所有用例。然后,可以将Renan的解决方案用于其余案例。

public TResult Foo<TResult> (Func<TResult> f)
{
    return f();
}

public TResult Foo<T1, TResult>(Func<T1, TResult> f, T1 t1)
{
    return f(t1);
}

public TResult Foo<T1, T2, TResult>(Func<T1, T2, TResult> f, T1 t1, T2 t2)
{
    return f(t1, t2);
}

...