Question

我提前为标题道歉，但这是我能想到的描述行动的最佳方式。

要求是处理消息总线的请求。进入的请求可能与将这些请求相关联或分组的id相关。我想要的行为是同步处理关联ID的请求流。但是，可以异步处理不同的ID。

我使用并发字典来跟踪正在处理的请求和链接中的谓词。

这是为了提供相关请求的同步处理。

然而，我得到的行为是第一个请求被处理，第二个请求被删除。

我已经从控制台应用程序附加了示例代码来模拟问题。

任何方向或反馈都将受到赞赏。

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Threading.Tasks.Dataflow;

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            var requestTracker = new ConcurrentDictionary<string, string>();

            var bufferBlock = new BufferBlock<Request>();

            var actionBlock = new ActionBlock<Request>(x => 
            {
                Console.WriteLine("processing item {0}",x.Name);
                Thread.Sleep(5000);
                string itemOut = null;
                requestTracker.TryRemove(x.Id, out itemOut);
            });

            bufferBlock.LinkTo(actionBlock, x => requestTracker.TryAdd(x.Id,x.Name));


            var publisher = Task.Run(() =>
            {
                var request = new Request("item_1", "first item");
                bufferBlock.SendAsync(request);

                var request_1 = new Request("item_1", "second item");
                bufferBlock.SendAsync(request_1);

            });

            publisher.Wait();
            Console.ReadLine();
        }
    }

    public class Request
    {
        public Request(string id, string name)
        {
            this.Id = id;
            this.Name = name;
        }
        public string Id { get; set; }
        public string Name { get; set; }
    }
}

Answer 1

你说你想要并行处理一些请求（至少我认为这是“异步”的意思），但ActionBlock默认不是并行的。要更改此设置，请设置MaxDegreeOfParallelism。
您尝试使用TryAdd()作为过滤器，但由于两个原因而无法使用：
1. 过滤器只调用一次，不会自动重试或类似的任何内容。这意味着，如果某个项目没有通过，即使在阻止它的项目完成后，它也永远不会通过。
2. 如果某个项目卡在某个块的输出队列中，则其他任何项目都不会离开该块。这可能会显着降低并行度，即使你以某种方式解决了上一期问题。

我认为这里最简单的解决方案是为每个组设置一个块，这样，每个组中的项目将按顺序处理，但来自不同组的项目将并行处理。在代码中，它看起来像：

var processingBlocks = new Dictionary<string, ActionBlock<Request>>();

var splitterBlock = new ActionBlock<Request>(request =>
{
    ActionBlock<Request> processingBlock;

    if (!processingBlocks.TryGetValue(request.Id, out processingBlock))
    {
        processingBlock = processingBlocks[request.Id] =
            new ActionBlock<Request>(r => /* process the request here */);
    }

    processingBlock.Post(request);
});

这种方法的问题在于组的处理块永远不会消失。如果你无法负担（它会导致内存泄漏），因为你将拥有大量的群组，那么hashing approach suggested by I3arnon就可以了。

Answer 2

我认为这是因为您的LinkTo()设置不正确。通过使用LinkTo()并将函数作为参数传递，您将添加条件。所以这一行：

bufferBlock.LinkTo(actionBlock, x => requestTracker.TryAdd(x.Id, x.Name));

基本上是说，将数据从bufferBlock传递到actionBlock，如果你能够添加到你的并发字典，这不一定有意义（至少在你的示例代码中）

相反，你应该将你的bufferBlock链接到没有lambda的actionblock，因为在这种情况下你不需要条件链接（至少我不是根据你的示例代码这么认为）。

此外，请查看此SO问题，看看您是否应该使用SendAsync()或Post()，因为只需将数据添加到管道中就可以更轻松地处理Post()：{ {3}}。 SendAsync将返回一个任务，而Post将根据成功进入管道返回true / false。

因此，基本上找出问题所在，你需要处理块的延续。 MSDN在他们的TPL数据流介绍中提供了一个很好的教程：TPL Dataflow, whats the functional difference between Post() and SendAsync()?它基本上是这样的：

//link to section
bufferBlock.LinkTo(actionBlock);
//continuations
bufferBlock.Completion.ContinueWith(t =>
{
     if(t.IsFaulted)  ((IDataFlowBlock).actionBlock).Fault(t.Exception); //send the exception down the pipeline
     else actionBlock.Complete(); //tell the next block that we're done with the bufferblock
 });

然后，您可以在等待管道时捕获异常（AggregateException）。您是否真的需要在实际代码中使用concurrentdictionary进行跟踪，因为当它无法添加时可能会导致问题，因为当linkto谓词返回false时，它不会将数据传递到管道的下一个块中

Microsoft TPL Dataflow - 同步处理关联请求

2 个答案: