C# TPL数据流-如何调用多个项目的操作项

我是第三方物流数据流的新手。我有一个需要处理的项目编号列表。一个项目可能有大约8000个项目，我需要获取项目中每个项目的数据，然后将这些数据推送到5个单独的服务器中

这是我到目前为止编写的代码。我被困在如何将这些数据加载到5台服务器的步骤中。我不确定这是否正确编码。任何建议都将不胜感激

public  static bool PushData(string projectId)
{
    var linkCompletion = new DataflowLinkOptions
    {
        PropagateCompletion = true
    };

    var projectItems = new TransformBlock<ProjectDTO, ProjectDTO>(
        dto => dto.GetItemData(dto), new ExecutionDataflowBlockOptions { MaxDegreeOfParallelism = 5 });

    var itemData = new ActionBlock<ProjectDTO>(
         dto =>  PostEachServerAsync(dto, "server1", "setmemcache"), new ExecutionDataflowBlockOptions { MaxDegreeOfParallelism = 5 });


    projectItems.LinkTo(projectRules, linkCompletion);

    IList<ProjectDTO> dtoList = new List<ProjectDTO>();
    dtoList = MemcachedDTO.GetDataByProject(projectId);

    foreach (ProjectDTOd in dtoList)
    {
        projectItems.Post(d);
    }

    projectItems.Complete();
    projectItems.Completion.Wait();
    return false;
}

公共静态bool PushData（字符串projectId）
{
var linkCompletion=新数据流链接选项
{
完成=真
};
var projectItems=新的TransformBlock(
dto=>dto.GetItemData（dto），新的ExecutionDataflowBlockOptions{MaxDegreeOfParallelism=5}）；
var itemData=新动作块(
dto=>PostEachServerAsync（dto，“server1”，“setmemcache”），新的ExecutionDataflowBlockOptions{MaxDegreeOfParallelism=5}）；
项目项链接到（项目规则，链接完成）；
IList dtoList=新列表（）；
dtoList=MemcachedDTO.GetDataByProject（projectId）；
foreach（dtoList中的ProjectDTOd）
{
项目项目.员额（d）；
}
projectItems.Complete（）；
projectItems.Completion.Wait（）；
返回false；
}

---

这是我的代码现在-但它没有正确完成-谁能告诉我我做错了什么

             [HttpGet]
    public HttpResponseMessage ReloadItem(string projectQuery)
    {
        try
        {

            var linkCompletion = new DataflowLinkOptions
            {
                PropagateCompletion = true
            };

            IList<string> projectIds = projectQuery.Split(',').ToList();
            IEnumerable<string> serverList = ConfigurationManager.AppSettings["ServerList"].Split(',').Cast<string>();

            var iR = new TransformBlock<MemcachedDTO, MemcachedDTO>(
                dto => dto.GetIR(dto), new ExecutionDataflowBlockOptions { MaxDegreeOfParallelism = 3 });

            var pR = serverList.Select(
                    i => new { Id = i, Action = new ActionBlock<MemcachedDTO>(dto => PostEachServerAsync(dto, i, "set"), new ExecutionDataflowBlockOptions { MaxDegreeOfParallelism = 3 }) });

            List<MemcachedDTO> dtoList = new List<MemcachedDTO>();

            foreach (string pid in projectIds)
            {
                IList<MemcachedDTO> dtoTemp = new List<MemcachedDTO>();
                dtoTemp = MemcachedDTO.GetItemIdsByProject(pid);
                dtoList.AddRange(dtoTemp);
            }


            foreach (var action in pR)
            {
                iR.LinkTo(action.Action, linkCompletion);
            }

            foreach (MemcachedDTO d in dtoList)
            {
                iR.Post(d);
            }
            iR.Complete();
            foreach (var action in pR)
            {
                action.Action.Completion.Wait();
            }


            return Request.CreateResponse(HttpStatusCode.OK, new { message = projectIds.ToString() + " reload success" });
        }
        catch (Exception ex)
        {
            return Request.CreateResponse(HttpStatusCode.InternalServerError, new { message = ex.Message.ToString() });
        }
    }

[HttpGet]
公共HttpResponseMessage重载项（字符串项目查询）
{
尝试
{
var linkCompletion=新数据流链接选项
{
完成=真
};
IList projectId=projectQuery.Split（'，'）.ToList（）；
IEnumerable serverList=ConfigurationManager.AppSettings[“serverList”].Split（'，'）.Cast（）；
var iR=新转换块(
dto=>dto.GetIR（dto），新的ExecutionDataflowBlockOptions{MaxDegreeOfParallelism=3}）；
var pR=serverList。选择(
i=>new{Id=i，Action=newactionblock（dto=>PostEachServerAsync（dto，i，“set”），newexecutiondataflowblockoptions{MaxDegreeOfParallelism=3}）；
List dtoList=新列表（）；
foreach（项目中的字符串pid）
{
IList dtoTemp=新列表（）；
dtoTemp=MemcachedDTO.GetItemIdsByProject（pid）；
dtoList.AddRange（dtoTemp）；
}
foreach（pR中的var作用）
{
iR.LinkTo（action.action，linkCompletion）；
}
foreach（数据列表中的memcachedd到d）
{
国际关系员额（d）；
}
iR.Complete（）；
foreach（pR中的var作用）
{
action.action.Completion.Wait（）；
}
return Request.CreateResponse（HttpStatusCode.OK，new{message=projectds.ToString（）+“reload success”}）；
}
捕获（例外情况除外）
{
return Request.CreateResponse（HttpStatusCode.InternalServerError，new{message=ex.message.ToString（）}）；
}
}

您的代码根本无法编译，如何运行它

首先，不要用

.Wait（）

阻塞线程，请在此处使用。第二，您需要一个用于通知多个块的数据。第三，您需要5个不同的s，而不是并行度为5的1。第四，你在等待错误的任务-等待最后一个区块完成，而不是第一个区块完成，因此在你的情况下，你需要等待5个区块完成

因此，您的代码可以是这样的（我假设

projectRules

和

itemsData

是同一个块）：

公共静态异步任务PushData（字符串projectId）
{
var linkCompletion=新数据流链接选项
{
完成=真
};
var projectItems=新的TransformBlock(
dto=>dto.GetItemData（dto），新的ExecutionDataflowBlockOptions{MaxDegreeOfParallelism=5}）；
var broadcast=new BroadcastBlock（）；
projectItems.LinkTo（广播、链接完成）；
var pR=serverList。选择(
i=>new{Id=i，Action=newactionblock（dto=>PostEachServerAsync（dto，i，“set”），newexecutiondataflowblockoptions{MaxDegreeOfParallelism=3}）；
foreach（pR中的var作用）
{
broadcast.LinkTo（action.action，linkCompletion）；
}
var dtoList=MemcachedDTO.GetDataByProject（projectd）；
foreach（dtoList中的变量d）
{
项目项目.员额（d）；
}
projectItems.Complete（）；
//等待所有动作块完成
等待任务完成（项目规则1.完成，项目规则2.完成，项目规则3.完成，项目规则4.完成，项目规则5.完成）；
返回false；
}

感谢您的回复-项目项与itemdata不在同一块中-这是因为1）我将首先获取对应于每个项目编号的项目列表2）根据步骤1）中的项目ID获取项目数据。在那之后，我需要将数据推送到5台服务器。我对如何迭代项目ID以获取项目ID以及与每个项目ID相对应的数据感到有点迷茫。这是我的代码，但它没有正确完成。我做错了什么？1。您没有使用BroadcastBlock，因此只有第一个block将获得消息。2.您正在使用

Wait

阻塞线程，这是错误的，请使用

async

Wait`。3.因此，这里不是为您编译代码的地方。你有了这个想法，你就成功了。很抱歉给你带来不便。这是我第一次在SO发帖。我已经编辑了我的代码，现在可以编译了。我不确定我是否被阻止了。你能给我举个例子吗？因此，我基本上希望将数据推送到所有服务器，比如这里的var pR=serverList.Select（I=>new{Id=I，Action=newactionblock（dto=>PostEachServerAsync（dto，I，“set”），new Ex

public static async Task<bool> PushData(string projectId)
{
    var linkCompletion = new DataflowLinkOptions
    {
        PropagateCompletion = true
    };

    var projectItems = new TransformBlock<ProjectDTO, ProjectDTO>(
        dto => dto.GetItemData(dto), new ExecutionDataflowBlockOptions { MaxDegreeOfParallelism = 5 });

    var broadcast = new BroadcastBlock<ProjectDTO>();
    projectItems.LinkTo(broadcast, linkCompletion);

    var pR = serverList.Select(
            i => new { Id = i, Action = new ActionBlock<MemcachedDTO>(dto => PostEachServerAsync(dto, i, "set"), new ExecutionDataflowBlockOptions { MaxDegreeOfParallelism = 3 }) });

    foreach (var action in pR)
    {
        broadcast.LinkTo(action.Action, linkCompletion);
    }

    var dtoList = MemcachedDTO.GetDataByProject(projectId);

    foreach (var d in dtoList)
    {
        projectItems.Post(d);
    }
    projectItems.Complete();

    // wait all the action blocks to finish
    await Task.WhenAll(projectRules1.Completion, projectRules2.Completion, projectRules3.Completion, projectRules4.Completion, projectRules5.Completion);
    return false;
}