c# - 希望通过异步调用提高我的 WebService 的速度，但不确定如何

Question

我正在编写一个使用第三方网络服务并大大扩展功能的网络服务。例如，在工作流的一部分中，我必须循环访问一个 API 调用的结果，并针对每个结果进行另一个 API 调用，以便返回实际可用的结果。目前，这会产生大约 7,500 行 XML，以及 3-4 分钟的加载时间(当然，这个加载时间是基于在一台糟糕的 PC 上以 Debug模式从 Visual Studio 运行 WebService 并连接糟糕的互联网，我希望它在从高端 Windows 服务器上运行时会更加快速)。我想做的是找到一些方法为每个 API 调用生成一个新的异步线程(这样每次迭代都不必等待上一次迭代完成)，但我不确定如何做到这一点并且仍然能够在同一个函数调用中返回 XML 输出。有什么想法吗？

::EDIT::-- 这是我用来生成 XML 的代码。请注意，所有函数调用都只是第三方 API 的 API 调用的包装器。

public List<AvailabilityList> getResortsForDate(String month, int year) {
        List<RegionList> regions = this.getRegionLists( );
        List<AvailabilityList> availability = new List<AvailabilityList>();
        foreach(RegionList parent in regions)
        {
            foreach(Region child in parent.Regions)
            {
                if (!String.Equals(child.ID, "?"))
                {
                    int countryID = Int32.Parse(parent.CountryID);
                    AvailabilityList current = this.getExchangeAvailability(countryID, month, year, child.ID);
                    if (current.ListCount != 0)
                    {
                        availability.Add(current);
                    }
                }
            }
        }
        return availability;
    }

::编辑 #2::解决方案!这是我最终使用的解决方案，这是对我选择的答案的一个小调整。谢谢!在我之前的代码计时(5分1秒)之后，这段代码在1分6秒是一个巨大的改进，30秒的时间属于另一种方法，我也会优化!

public List<AvailabilityList> _asyncGetResortsForDate(String month, int year) {
        List<RegionList> regions = this.getRegionLists();
        List<AvailabilityList> availability = new List<AvailabilityList>();

        List<WaitHandle> handles = new List<WaitHandle>();
        List<AvailabilityList> _asyncResults = new List<AvailabilityList>();

        regions.ForEach(parent => {
            parent.Regions.ForEach(child => {
                    if (!String.Equals(child.ID, "?")) {
                        int countryID = Int32.Parse(parent.CountryID);

                        Func<AvailabilityList> _getList = () => this.getExchangeAvailability(countryID, month, year, child.ID);

                        IAsyncResult res = _getList.BeginInvoke(new AsyncCallback(
                            x => {
                                AvailabilityList result = (x.AsyncState as Func<AvailabilityList>).EndInvoke(x);
                                if (result.ListCount > 0)
                                {
                                    _asyncResults.Add(result);
                                }

                            }), _getList);
                        while (handles.Count >= 60)
                        {
                            int item = WaitHandle.WaitAny(handles.ToArray(  ));
                            handles.RemoveAt(item);
                        }
                        handles.Add(res.AsyncWaitHandle);
                    }
                });
        });

        WaitHandle.WaitAll(handles.ToArray());

        return _asyncResults;
    }

Answer 1

像这样处理等待句柄数组表明您的代码中有些东西太复杂了。您可以使用任务并行库完成更简洁的工作。

例如:

public List<AvailabilityList> _asyncGetResortsForDate(String month, int year)
{
    List<RegionList> regions = this.getRegionLists();
    List<AvailabilityList> availability = new List<AvailabilityList>();

    List<Task> tasks = new List<Task>(); 
    List<AvailabilityList> _asyncResults = new List<AvailabilityList>(); 

    regions.ForEach(parent =>
    {
        parent.Regions.ForEach(child =>
        {
             if (!String.Equals(child.ID, "?"))
             {
                 int countryID = Int32.Parse(parent.CountryID);
                 var childId = child.ID;

                 Task t = Task.Factory.StartNew((s) =>
                     {
                         var rslt = getExchangeAvailability(countryId, month, year, childId);
                         lock (_asyncResults)
                         {
                             _asyncResults.Add(rslt);
                         }
                      });
                 tasks.Add(t);
             }
        }); 
    });

    Task.WaitAll(tasks);

    return _asyncResults; 
}

(我没有尝试编译它，但你明白了这个想法的要点。)

让 TPL 担心 64 个等待句柄限制。

另请注意，您的代码有一个等待发生的错误。由于多个任务可能会尝试将结果添加到 _asyncResults列表，你必须用锁来保护它。 List<T>.Add不是线程安全的。如果两个线程试图同时访问它，您将以损坏的数据或异常结束。

上面的也可能更快。我不确定如果您启动多个异步调用会发生什么。线程池很可能会为它们创建最大数量的线程，并启动它们全部运行。您最终可能会得到 25 个或更多正在运行的线程以及伴随的上下文切换等。另一方面，TPL 在使用线程方面要聪明得多。它将创建更少的并发线程，从而避免大量的上下文切换。

如果使用 Task<List<AvailabilityList>> 就可以完全避免锁定.然后你的代码会变成这样:

Task<List<AvailabilityList>> t = Task<List<AvailabilityList>>.Factory.StartNew((s) =>
    {
        return getExchangeAvailability(countryId, month, year, childId);
    }

然后，在你的 Task.WaitAll(tasks) 之后:

foreach (var t in tasks)
{
    _asyncResults.Add(t.Result);
}

事实上，你可以去掉Task.WaitAll(tasks) , 自 Task<T>.Result阻塞直到结果可用。