c# - 在 ASP.NET 中缓存异步方法的结果

Question

我有一个简单的 MVC Controller ，我将其设为异步，它使用 await Task.WhenAll 从 Web 服务获取数据。我想缓存这些调用的结果，这样我就不必一直调用 API。目前，当我收到响应时，我将结果缓存在 View Controller 中，但理想情况下，我希望调用 API 的方法能够处理缓存。问题是该方法还不能访问结果，因为它是异步的并且只返回一个任务。

是否可以使用另一种方法在结果返回后缓存它们？

public async Task<ActionResult> Index()
{
    // Get data asynchronously
    var languagesTask = GetDataAsync<List<Language>>("languages");
    var currenciesTask = GetDataAsync<List<Currency>>("currencies");

    await Task.WhenAll(languagesTask, currenciesTask);


    // Get results
    List<Language> languages = languagesTask.Result;
    List<Currency> currencies = currenciesTask.Result;


    // Add results to cache
    AddToCache("languages", languages);
    AddToCache("currencies", currencies);


    // Add results to view and return
    ViewBag.languages = languages;
    ViewBag.currencies = currencies;

    return View();
}

public async Task<T> GetDataAsync<T>(string operation)
{
    // Check cache for data first
    string cacheName = operation;

    var cacheData = HttpRuntime.Cache[cacheName];

    if (cacheData != null)
    {
        return (T)cacheData;
    }


    // Get data from remote api
    using (HttpClient client = new HttpClient())
    {
        client.BaseAddress = new Uri("https://myapi.com/");

        var response = await client.GetAsync(operation);

        // Add result to cache
        //...

        return (await response.Content.ReadAsAsync<T>());
    }
}

Answer 1

只要您的缓存实现在内存中，您就可以缓存任务本身而不是任务结果:

public Task<T> GetDataAsync<T>(string operation)
{
  // Check cache for data first
  var task = HttpRuntime.Cache[operation] as Task<T>;
  if (task != null)
    return task;

  task = DoGetDataAsync(operation);
  AddToCache(operation, task);
  return task;
}

private async Task<T> DoGetDataAsync<T>(string operation)
{
  // Get data from remote api
  using (HttpClient client = new HttpClient())
  {
    client.BaseAddress = new Uri("https://myapi.com/");
    var response = await client.GetAsync(operation);
    return (await response.Content.ReadAsAsync<T>());
  }
}

这种方法还有一个额外的好处，即如果多个 HTTP 请求尝试获取相同的数据，它们实际上将共享任务本身。因此它共享实际的异步操作而不是结果。

但是，这种方法的缺点是 Task<T>不可序列化，因此如果您使用自定义磁盘支持的缓存或共享缓存(例如 Redis)，则此方法无效。