Caching odata Web Api

I am developing an OData API for my Asp.net core application and i want to implement caching on this.

The problem is all my endpoints will be IQueryable with a queryable services with no execution at all. so i can't implement any caching on service level

Controller

public class TagsController : ODataController
{
    private readonly ITagService _tagService;
    private readonly ILogger<TagsController> _logger;
   

    public TagsController(ITagService tagService, ILogger<TagsController> logger)
    {
        _tagService = tagService;
        _logger = logger;
    }

    [HttpGet("odata/tags")]
    [Tags("Odata")]
    [AllowAnonymous]
    [EnableCachedQuery]
    public ActionResult<IQueryable<Tag>> Get()
    {
        try
        {
            return Ok(_tagService.GetAll());
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Some unknown error has occurred.");
            return BadRequest();
        }
    }
}

So I tried to apply an extension on EnableQuery attribute to add the caching implementation on it. so i added the following

public class EnableCachedQuery : EnableQueryAttribute
{
    private IMemoryCache _memoryCache;

    public EnableCachedQuery()
    {
        _memoryCache = new MemoryCache(new MemoryCacheOptions());
    }

    public override void OnActionExecuting(ActionExecutingContext actionContext)
    {
        //var url = GetAbsoluteUri(actionContext.HttpContext);

        var path = actionContext.HttpContext.Request.Path + actionContext.HttpContext.Request.QueryString;

        //check cache
        if (_memoryCache.TryGetValue(path, out ObjectResult value))
        {
            actionContext.Result = value;
        }
        else
        {
            base.OnActionExecuting(actionContext);
        }
    }

    public override void OnActionExecuted(ActionExecutedContext context)
    {
        if (context.Exception != null)
            return;

        var path = context.HttpContext.Request.Path + context.HttpContext.Request.QueryString;
        var cacheEntryOpts = new MemoryCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromMinutes(15));
        base.OnActionExecuted(context);
        _memoryCache.Set(path, context.Result, cacheEntryOpts);
    }
}

the first request completed successfully and retrieved the data correctly with filters and queries applied. then when tried to add the data to cache the context.Result holds the ObjectResult and then in the second request which should be cached the value was there but with an error in executing which means that the cached value is not the final output value that should be passed to the Result

Cannot access a disposed context instance. A common cause of this error is disposing a context instance that was resolved from dependency injection and then later trying to use the same context instance elsewhere in your application. This may occur if you are calling 'Dispose' on the context instance, or wrapping it in a using statement. If you are using dependency injection, you should let the dependency injection container take care of disposing context instances.    
Object name: 'ApplicationDbContext'.

============================ Update:

public class ApplicationDbContext : IdentityDbContext<User, Account, Session>, IApplicationDbContext
{
public ApplicationDbContext(
    DbContextOptions options,
    IApplicationUserService currentUserService,
    IDomainEventService domainEventService,
    IBackgroundJobService backgroundJob,
    IDomainEventService eventService,
    IDateTime dateTime) : base(options, currentUserService, domainEventService, backgroundJob, dateTime) { }

public DbSet<Tag> Tags => Set<Tag>();

protected override void OnModelCreating(ModelBuilder builder)
{
    base.OnModelCreating(builder);

    var entityTypes = builder.Model.GetEntityTypes()
        .Where(c => typeof(AuditableEntity).IsAssignableFrom(c.ClrType))
        .ToList();

    foreach (var type in entityTypes)
    {
        var parameter = Expression.Parameter(type.ClrType);

        var deletedCheck = Expression.Lambda
            (Expression.Equal(Expression.Property(parameter, nameof(AuditableEntity.Deleted)), Expression.Constant(false)), parameter);

        type.SetQueryFilter(deletedCheck);

    }

    builder.ApplyConfigurationsFromAssembly(typeof(ApplicationDbContext).Assembly);
    builder.ApplySeedsFromAssembly(typeof(ApplicationDbContext).Assembly);

}
}