Question

我寻找JoinBlock的替代方法，它可以通过n-TransformBlocks链接到所有TransformBlock源块的连接/合并消息，以便将这样的on的集合传递给另一个数据流块。

JoinBlock可以正常工作，但仅限于连接3个源块。它也遭受了相当多的低效率（连接2个源块的偶数值类型（int）非常慢）。有没有办法从TransformBlocks返回任务并等待所有TransformBlocks在接受Task<item>之前有完成的任务要传递？

还有其他想法吗？我可能有1-20个这样的转换块，我需要在传递连接项集合之前将它们连接在一起。保证每个转换块为每个“转换”的输入项返回一个输出项。

编辑：请求澄清：

根据我以前的一个问题，我按如下方式设置了JoinBlocks：

public Test()
{
    broadCastBlock = new BroadcastBlock<int>(i =>
        {
            return i;
        });

    transformBlock1 = new TransformBlock<int, int>(i =>
        {
            return i;
        });

    transformBlock2 = new TransformBlock<int, int>(i =>
        {
            return i;
        });

    joinBlock = new JoinBlock<int, int>();

    processorBlock = new ActionBlock<Tuple<int, int>>(tuple =>
        {
            //Console.WriteLine("tfb1: " + tuple.Item1 + "tfb2: " + tuple.Item2);
        });

    //Linking
    broadCastBlock.LinkTo(transformBlock1, new DataflowLinkOptions { PropagateCompletion = true });
    broadCastBlock.LinkTo(transformBlock2, new DataflowLinkOptions { PropagateCompletion = true });
    transformBlock1.LinkTo(joinBlock.Target1);
    transformBlock2.LinkTo(joinBlock.Target2);
    joinBlock.LinkTo(processorBlock, new DataflowLinkOptions { PropagateCompletion = true });
}

public void Start()
{
    Stopwatch watch = new Stopwatch();
    watch.Start();

    const int numElements = 1000000;

    for (int i = 1; i <= numElements; i++)
    {
        broadCastBlock.Post(i);
    }

    ////mark completion
    broadCastBlock.Complete();
    Task.WhenAll(transformBlock1.Completion, transformBlock2.Completion).ContinueWith(_ => joinBlock.Complete());


    processorBlock.Completion.Wait();

    watch.Stop();

    Console.WriteLine("Time it took: " + watch.ElapsedMilliseconds + " - items processed per second: " + numElements / watch.ElapsedMilliseconds * 1000);
    Console.ReadLine();
}

Answer 1

执行此操作的一种方法是使用BatchBlock并将Greedy设置为false。在此配置中，只有来自n个n个不同块的n项等待消耗它时，块才会执行任何操作（其中BatchBlock是您在创建{时设置的数字} {1}}）。当发生这种情况时，它会立即使用所有n个项目，并生成一个包含所有项目的数组。

这个解决方案的一个警告是结果数组没有排序：你不会知道哪个项来自哪个来源。我不知道它的性能与JoinBlock相比如何，你必须自己测试一下。（虽然我理解如果使用BatchBlock这种方式比较慢，因为非贪婪消费需要开销。）

Answer 2

如果您要为每个项目执行多个并行操作，恕我直言，在单个块内执行这些操作更有意义，而不是将它们拆分为多个块，然后尝试将独立结果再次合并为单个对象。所以我的建议是做这样的事情：

var block = new TransformBlock<MyClass, MyClass>(async item =>
{
    Task<SomeType1> task1 = Task.Run(() => CalculateProperty1(item.Id));
    Task<SomeType2> task2 = Task.Run(() => CalculateProperty2(item.Id));
    await Task.WhenAll(task1, task2).ConfigureAwait(false);
    item.Property1 = task1.Result;
    item.Property2 = task2.Result;
    return item;
}, new ExecutionDataflowBlockOptions()
{
    MaxDegreeOfParallelism = 2
});

在上面的示例中，类型MyClass的项目通过TransformBlock传递。每个项目的属性Property1和Property2使用每个属性的单独Task并行计算。然后等待两个任务，当两个任务都完成时，将结果分配给该项目的属性。最后，返回已处理的项目。

这种方法唯一要注意的是，并行度将是内部并行操作与块的MaxDegreeOfParallelism选项的乘积。因此，在上面的示例中，并行度为2 x 2 =4。确切地说，这将是最大并行度，因为两个内部计算之一可能会比另一个慢。因此，在任何给定的时刻，实际的并行度可以在2到4之间。

TPL Dataflow是JoinBlock限制的替代方案吗？

2 个答案: