Q: Unable To Load View Asynchronously - ASP.NET Core MVC I am currently working on a website that uses a Redis cache implementation, EF Core, and async/await. I'm running into a strange problem when trying to load a view with a view model from an async controller method.
Controller method:
public async Task<ActionResult> Events()
{
        var clientEvents = await _eventService.GetEvents();

        var model = new EventsListViewModel(clientEvents.FutureEvents, clientEvents.PastEvents, false) //Change this)
        {
            ClientName = _tenantService.Client.Name,
            HasSearch = clientEvents.SearchConfig.IsDisplayed
        };

        return View(model);
}

Service method:
    public async Task<ClientEvents> GetEvents()
    {
        var cacheValue = await _distributedCache.GetStringAsync($"{REDIS_EVENTS_PREFIX}{_clientId}");
        ClientEvents clientEvents = null;

        if (string.IsNullOrWhiteSpace(cacheValue))
        {
            var config = await _activateDbContext
                .ClientEventSearchConfigurations
                .AsNoTracking()
                .Where(ec => ec.ClientId == _clientId)
                .FirstOrDefaultAsync();

            var futureEvents = await _activateDbContext
                .Events
                .AsNoTracking()
                .Include(e => e.Venue)
                .Include(e => e.EventType)
                .Where(e => e.ClientId == _clientId)
                .Where(e => e.IsActive)
                .Where(e => (e.StartDate <= DateTime.UtcNow && e.EndDate >= DateTime.UtcNow) || e.StartDate >= DateTime.UtcNow)
                .OrderBy(e => e.StartDate)
                .ToListAsync();

            var pastEvents = await _activateDbContext
                .Events
                .AsNoTracking()
                .Include(e => e.Venue)
                .Include(e => e.EventType)
                .Where(e => e.ClientId == _clientId)
                .Where(e => e.IsActive)
                .Where(e => e.EndDate < DateTime.UtcNow)
                .OrderByDescending(e => e.StartDate)
                .Take(5)
                .ToListAsync();

            clientEvents = new ClientEvents
            {
                SearchConfig = config,
                FutureEvents = futureEvents,
                PastEvents = pastEvents
            };

            var options = new DistributedCacheEntryOptions().SetSlidingExpiration(TimeSpan.FromDays(1));

            await _distributedCache.SetStringAsync($"{REDIS_EVENTS_PREFIX}{_clientId}", JsonConvert.SerializeObject(clientEvents, Formatting.Indented,
                new JsonSerializerSettings()
                {
                    ReferenceLoopHandling = ReferenceLoopHandling.Ignore
                }), options);
        }
        else
        {
            clientEvents = JsonConvert.DeserializeObject<ClientEvents>(cacheValue);
        }

        return clientEvents;
    }

With this implementation, the return View(model); line in the controller method is showing that the model has been properly populated, but once that line is ran, I see this exception:

IFeatureCollection has been disposed. Object name: 'Collection'

Strangely, if I simply change the service method to use
var cacheValue = _distributedCache.GetString($"{REDIS_EVENTS_PREFIX}{_clientId}");

everything works as expected. I'm banging my head into my desk trying to figure this out, any help is appreciated.
EDIT: Adding code from Startup.cs -
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddDbContext<ActivateDBContext>(options =>
            options.UseSqlServer(_configuration[ConfigurationConstants.ACTIVATE_DB_CONNECTION_STRING]));
        services.AddStackExchangeRedisCache(options =>
        {
            options.Configuration = _configuration[ConfigurationConstants.REDIS_CONNECTION_STRING];
            options.InstanceName = _configuration[ConfigurationConstants.REDIS_INSTANCE_NAME];
        });
        services.AddRazorPages();
        services.AddControllersWithViews();
        services.AddDistributedMemoryCache();
        services.AddIPStackApi();
        services.AddResponseCompression();
        services.AddPortableObjectLocalization(options => options.ResourcesPath = "Localization");
        services.Configure<RequestLocalizationOptions>(options =>
        {
            var supportedCultures = new List<CultureInfo>
            {
                new CultureInfo("en-US"),
                new CultureInfo("en"),
                new CultureInfo("fr-FR"),
                new CultureInfo("fr"),
                new CultureInfo("es"),
                new CultureInfo("es-ES"),
            };
            options.DefaultRequestCulture = new RequestCulture("en-US");
            options.SupportedCultures = supportedCultures;
            options.SupportedUICultures = supportedCultures;
        });
        services.AddScoped<ITenantService, TenantService>();
        services.AddScoped<ILocationService, LocationService>();
        services.AddScoped<IEventService, EventService>();
        services.AddScoped<IAncillarySearchService, AncillarySearchService>();
        services.AddMvc().AddViewLocalization(LanguageViewLocationExpanderFormat.Suffix);

    }

