如何在 C# HttpClient 中循环调用分页 URL 以从 JSON 结果下载所有页面

我的第一个问题，所以请友善......:)

我正在使用C# HttpClient调用作业 API 端点。

这是端点：Jobs API Endpoint（不需要密钥，点击即可） http://service.dice.com/api/rest/jobsearch/v1/simple.json?skill=ruby

这给了我这样的 JSON。

{
  "count": 1117,
  "firstDocument": 1,
  "lastDocument": 50,
  "nextUrl": "\/api\/rest\/jobsearch\/v1\/simple.json?areacode=&country=&state=&skill=ruby&city=&text=&ip=&diceid=&page=2",
  "resultItemList": [
    {
      "detailUrl": "http:\/\/www.dice.com\/job\/result\/90887031\/918715?src=19",
      "jobTitle": "Sr Security Engineer",
      "company": "Accelon Inc",
      "location": "San Francisco, CA",
      "date": "2017-03-30"
    },
    {
      "detailUrl": "http:\/\/www.dice.com\/job\/result\/cybercod\/BB7-13647094?src=19",
      "jobTitle": "Platform Engineer - Ruby on Rails, AWS",
      "company": "CyberCoders",
      "location": "New York, NY",
      "date": "2017-04-16"
    }
 ]
}

我已经粘贴了完整的 JSON 片段，以便您可以在答案中使用它。完整的结果真的很期待这里。

这是 C# 类。

using Newtonsoft.Json;
using System.Collections.Generic;

namespace MyNameSpace
{
    public class DiceApiJobWrapper
    {
        public int count { get; set; }
        public int firstDocument { get; set; }
        public int lastDocument { get; set; }
        public string nextUrl { get; set; }

        [JsonProperty("resultItemList")]
        public List<DiceApiJob> DiceApiJobs { get; set; }
    }

    public class DiceApiJob
    {
        public string detailUrl { get; set; }
        public string jobTitle { get; set; }
        public string company { get; set; }
        public string location { get; set; }
        public string date { get; set; }
    }
}

当我使用 HttpClient 调用 URL 并使用 JSON.NET 反序列化时，我确实正确地取回了数据。

这是我从控制台应用程序调用的代码Main方法（因此static列表，我认为这可以更好地重构？）

   private static List<DiceApiJob> GetDiceJobs()
    {
        HttpClient httpClient = new HttpClient();
        var jobs = new List<DiceApiJob>();

        var task = httpClient.GetAsync("http://service.dice.com/api/rest/jobsearch/v1/simple.json?skill=ruby")
          .ContinueWith((taskwithresponse) =>
          {
              var response = taskwithresponse.Result;
              var jsonString = response.Content.ReadAsStringAsync();
              jsonString.Wait();

              var result =  JsonConvert.DeserializeObject<DiceApiJobWrapper>(jsonString.Result);
              if (result != null)
              {
                  if (result.DiceApiJobs.Any())
                      jobs = result.DiceApiJobs.ToList();

                  if (result.nextUrl != null)
                  {
                      //
                      // do this GetDiceJobs again in a loop? How?? Any other efficient elegant way??
                  }
              }
          });
        task.Wait();

        return jobs;
    }

但现在，我如何检查是否有更多工作使用nextUrl场地？我知道我可以检查它是否不为空，如果不为空，则意味着还有更多工作需要取消。

我的调试和单步执行的结果 https://i.stack.imgur.com/N3sn7.png

如何以递归方式执行此操作，并且不会挂起且有一些延迟，这样我就不会超出 API 限制？我想我必须使用 TPL（任务并行库），但我很困惑。

谢谢你！ 〜肖恩

如果您担心应用程序的响应时间，并且希望在实际从 API 获取所有页面/数据之前返回一些结果，您可以循环运行您的进程，并为其提供一个回调方法，以便在它获取每个页面/数据时执行来自 API 的数据页。

这是一个示例：

public class Program
{
    public static void Main(string[] args)
    {
        var jobs = GetDiceJobsAsync(Program.ResultCallBack).Result;
        Console.WriteLine($"\nAll {jobs.Count} jobs displayed");
        Console.ReadLine();
    }

    private static async Task<List<DiceApiJob>> GetDiceJobsAsync(Action<DiceApiJobWrapper> callBack = null)
    {
        var jobs = new List<DiceApiJob>();
        HttpClient httpClient = new HttpClient();
        httpClient.BaseAddress = new Uri("http://service.dice.com");
        var nextUrl = "/api/rest/jobsearch/v1/simple.json?skill=ruby";

        do
        {
            await httpClient.GetAsync(nextUrl)
                .ContinueWith(async (jobSearchTask) =>
                {
                    var response = await jobSearchTask;
                    if (response.IsSuccessStatusCode)
                    {
                        string jsonString = await response.Content.ReadAsStringAsync();
                        var result = JsonConvert.DeserializeObject<DiceApiJobWrapper>(jsonString);
                        if (result != null)
                        {
                            // Build the full list to return later after the loop.
                            if (result.DiceApiJobs.Any())
                                jobs.AddRange(result.DiceApiJobs.ToList());

                            // Run the callback method, passing the current page of data from the API.
                            if (callBack != null)
                                callBack(result);

                            // Get the URL for the next page
                            nextUrl = (result.nextUrl != null) ? result.nextUrl : string.Empty;
                        }
                    }
                    else
                    {
                        // End loop if we get an error response.
                        nextUrl = string.Empty;
                    }
                });                

        } while (!string.IsNullOrEmpty(nextUrl));
        return jobs;
    }


    private static void ResultCallBack(DiceApiJobWrapper jobSearchResult)
    {
        if (jobSearchResult != null && jobSearchResult.count > 0)
        {
            Console.WriteLine($"\nDisplaying jobs {jobSearchResult.firstDocument} to {jobSearchResult.lastDocument}");
            foreach (var job in jobSearchResult.DiceApiJobs)
            {
                Console.WriteLine(job.jobTitle);
                Console.WriteLine(job.company);
            }
        }
    }
}

请注意，上面的示例允许回调方法在接收到数据后访问每一页数据。GetDiceJobsAsync方法。在这种情况下，控制台会在每个页面可用时显示该页面。如果你不想要回调选项，你可以简单地传递任何东西给GetDiceJobsAsync.

But the GetDiceJobsAsync完成后还会返回所有作业。所以你可以选择在最后对整个列表进行操作GetDiceJobsAsync.

至于达到 API 限制，您可以在重复循环之前在循环内插入一个小的延迟。但当我尝试时，我没有遇到限制我的请求的 API，所以我没有将其包含在示例中。