您能否在 C# 中将一个委托的结果链接为另一个委托的输入？

Question

我正在寻找一种方法来链接多个代表，以便一个代表的结果成为下一个代表的输入。我试图在方程求解程序中使用它，其中部分是通过不同的方法完成的。这个想法是，当您构建方程时，程序会添加代表并按特定顺序链接它们，以便可以正确求解。如果有更好的方法来解决这个问题，请分享。

Answer 1

这可能会有所帮助：

public static Func<T1, TResult> Compose<T1, T2, TResult>(Func<T1, T2> innerFunc, Func<T2, TResult> outerFunc) {
    return arg => outerFunc(innerFunc(arg));
}

这会执行函数组合，运行innerFunc并传递当提供初始参数时，结果返回到 outerFunc：

Func<double, double> floor = Math.Floor;
Func<double, int> convertToInt = Convert.ToInt32;

Func<double, int> floorAndConvertToInt = Compose(floor, convertToInt);

int result = floorAndConvertToInt(5.62);

Func<double, int> floorThenConvertThenAddTen = Compose(floorAndConvertToInt, i => i + 10);

int result2 = floorThenConvertThenAddTen(64.142);

Answer 2

是的，这是可能的 - 您需要确保委托的返回类型是被调用委托的参数类型。

很多 LINQ 都是以这种方式构建的，尽管您可能想看看表达式。

Answer 3

您描述的 API 类型称为 Fluent API。请参阅前面的文章以获得很好的教程。

关于委托链接，请查看 .NET 3.5 中的 LINQ 扩展方法，特别是 lambda 函数（委托）如何传递给函数导致 IEnumerable 结果，然后可以将其与另一个扩展方法 + lambda 链接。

在您的特定情况下，您可能需要创建一个名为 Functor 的类来接受委托并返回另一个也可以由委托操作的 Functor。

此致，

Answer 4

使用 GetIncationList 你可以实现这一点。

 Delegate[] chain = chained.GetInvocationList();

        int res = 10;
        for( int i = 0; i < chain.Length; i++ ) 
          {
              //Call chain[i]
                res =  chain[i](res);
          }

Answer 5

我自己一直在研究一个类似的问题，其中涉及调用一系列委托并将一个委托的输出传递给下一个委托（依此类推......），所以我想您可能有兴趣查看我开发的代码作为概念验证：

static class Program
{
    private static IList<Func<int, int>> delegateList = 
        new List<Func<int, int>>()
    {
        AddOne, AddOne, AddOne, AddOne, AddOne,
        AddOne, AddOne, AddOne, AddOne, AddOne,
    };

    static void Main(string[] args)
    {
        int number = 12;

        Console.WriteLine("Starting number: {0}", number);
        Console.WriteLine("Ending number: {0}", 
                          delegateList.InvokeChainDelegates(number));
        Console.ReadLine();
    }

    public static int AddOne(int num) { return num + 1; }

    public static T InvokeChainDelegates<T>(this IEnumerable<Func<T, T>> source, 
                                            T startValue)
    {
        T result = startValue;

        foreach (Func<T, T> function in source)
        {
            result = function(result);
        }

        return result;
    }
}

该序列必须包含相同类型的委托，因此不如已接受的答案那么强大，但通过一些调整，可以将这两个代码组合起来以提供强大的解决方案。