Q: Como faço para não precisar ficar fazendo requisição toda hora a api? Sou iniciante em desenvolvimento .net core e estou desenvolvendo uma aplicação que consome dados de uma api e mostra para os usuários, porém preciso ficar atualizando o site toda hora e isso demora um pouco.
Existe alguma forma de eu armazenar o retorno da api temporariamente em algum lugar?
Classe PageModel, que faz a requisição a api:
public class IndexModel : PageModel
{
  public Global Global { get; private set; }
  public Country[] Countries { get; private set; }

  public async Task OnGetAsync()
  {
    try
    {
      var create = RestService.For<IGetRootobject>("https://api.covid19api.com/summary");
      var result = await create.GetAsync(); // ou var result = create.GetAsync().GetAwaiter().GetResult();
      Global = result.Global;
      Countries = result.Countries;
    }
    catch (Exception e)
    {
      _logger.LogInformation("Erro na requisição http: " + e.Message);
    }
  }
}


A: O mais simples pode ser utilizado o Cache in-memory in ASP.NET Core (tradução: Cache na memória) que pode ser configurado em segundos, minutos, dias, etc. a sua permanência na memória da informação, ou seja, conforme a sua necessidade.
Para habilitar esse código no seu projeto no startup.cs no método ConfigureServices chame o método de extensão .AddMemoryCache() com mostrado no código:
public void ConfigureServices(IServiceCollection services)
{
    services.AddMemoryCache(); // adicione essa linha para funciona cache em memoria
    services.AddRazorPages();
}

com isso agora está habilitado pra ser utilizar nas Pages Razor e como está num batalha em algumas perguntas (1 e 2) segue o mesmo exemplo a seguir:
Adicione um propriedade:
public IMemoryCache MemoryCache { get; private set; }

depois no construtor da sua PageModel passe a interface e atribua a propriedade anteriormente criada para a injeção que é passado no construtor:
public MostrarModel(IMemoryCache memoryCache)
{
    MemoryCache = memoryCache;
}

a partir disso tem a possibilidade criar cache das informações na memória de qualquer tipo e por um simples estrutura de decisão pode buscar o valor no cache ou então criar o valor e armazenar no cache por uma quantidade de tempo (no caso exemplo logo abaixo no código completo foi adicionado trinta minutos, mas, como já foi relatado por ser configurado dias e horas a sua maneira):
Código final:
public class MostrarModel : PageModel
{
    public Country[] Countries { get; private set; }        
    public IMemoryCache MemoryCache { get; private set; } // cache
    public MostrarModel(IMemoryCache memoryCache) // injeção
    {
        MemoryCache = memoryCache; // atribuição
    }
    public async Task OnGetAsync()
    {
        //chave do cache (cada valor armazenado tem a sua) 
        string key = "countries_cache";
        //verificando se o valor está ou não em cache e tomando as medidas
        //dependendo da decisão na estrutura
        if (!MemoryCache.TryGetValue<Country[]>(key, out Country[] values))
        {
            var create = RestService
                .For<IGetRootobject>("https://api.covid19api.com/summary");
            var result = await create.GetAsync();
            Countries = result.Countries;
            //Armazenando em cache
            MemoryCache.Set(key, Countries, System.TimeSpan.FromMinutes(30));
        } 
        else
        {
            //recuperando do cache
            Countries = values;
        }
    }
}

A outra forma é com Distributed caching in ASP.NET Core que nesse caso é um informação compartilhada em vários servidores que melhora muito o desempenho e escabilidade e sua configuração é parecida com a anterior:
Adicione o método de extensão:
services.AddDistributedMemoryCache();

e no construtor e no código são bem parecidos com o anterior
private readonly IDistributedCache MemoryCache;
public MostrarModel(IDistributedCache memoryCache)
{
    MemoryCache = memoryCache;
}

e com os métodos GetAsync para recuperar e SetAsync para gravar o cache.

Vários tipos ainda existem como:

*

*Distributed caching in ASP.NET Core

*Distributed SQL Server Cache

*Distributed Redis Cache
