Есть ли лучший способ сделать недействительным кэш redis, используемый в приложении asp.net mvc?

Question

У меня есть приложение asp.net mvc 5 с структурой сущностей 6.1.

Для кэширования я использовал redis cache в своем приложении.это прекрасно работает для меня, все добавляют обновления и удаляют элементы с ключом.

я ожидаю, что всякий раз, когда приходит запрос на данные, он сначала проверяет кэш, а затем идет к базе данных, если данные не найдены вкэшировать, а затем заполнить кэш соответственно для последующих запросов.Я реализовал шаблон общего репозитория со стратегиями хранения и кэширования данных.

Проблема, с которой я сталкиваюсь, заключается в следующем:

• после того, как данные будут кэшированы, как я узнаючто любые операции обновления, удаления или добавления данных выполняются, а затем синхронизируются эти изменения данных с кэшем Redis

• как хранить данные в базе данных Redis для разных таблиц, поскольку каждая таблица может иметь данныес теми же значениями первичного ключа.затем при извлечении записи из redis, как мне узнать, что значение с ключом 1 взято из таблицы A или таблицы B.

Ниже я показал код для своего класса репозитория с инъекциейРедис кеш.что я хочу для таких методов, как GetList, firstOrDefault, во-первых, данные подаются из кеша, а затем из моей базы данных, если это необходимо

public abstract class GenericRepository<TEntity> :IBasicOperations<TEntity> 
where TEntity : class
{

    protected IDataStoreStrategy<TEntity> _dataStoreStrategy;    // Data Storage Strategy e.g, SQL SERVER
    protected ICachingStrategy _cachingStrategy;    // Caching Strategy e.g, Redis
    public GenericRepository(IDataStorageContext db, ICachingStrategy cache)
    {
        _cachingStrategy = cache;
        this._dataStoreStrategy = new BaseActions<TEntity>(db);
    }

    public void Add(TEntity entity, bool SaveChanges = true)
    {
        this._dataStoreStrategy.Add(entity, SaveChanges);
    }

    public async Task AddAsync(TEntity entity, bool SaveChanges = true)
    {
       await this._dataStoreStrategy.AddAsync(entity, SaveChanges);
    }

    public void AddRange(IEnumerable<TEntity> entities, bool SaveChanges = true)
    {
        this._dataStoreStrategy.AddRange(entities, SaveChanges);
    }

    public async Task AddRangeAsync(IEnumerable<TEntity> entities, bool SaveChanges = true)
    {
       await this._dataStoreStrategy.AddRangeAsync(entities, SaveChanges);
    }

    public TEntity FindById(object Id)
    {
       return this._dataStoreStrategy.FindById(Id);
    }

    public async Task<TEntity> FindByIdAsync(object Id)
    {
       return await _dataStoreStrategy.FindByIdAsync(Id);
    }

    public IQueryable<TEntity> FindWithCondition(Expression<Func<TEntity, bool>> filter = null, Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null, string includeProperties = "")
    {
        return this._dataStoreStrategy.FindWithCondition(filter,orderBy,includeProperties);
    }

    public TEntity First(Expression<Func<TEntity, bool>> where)
    {

        return this._dataStoreStrategy.First(where);

    }

    public Task<TEntity> FirstAsync(Expression<Func<TEntity, bool>> where)
    {
        return this._dataStoreStrategy.FirstAsync(where);
    }

    public IQueryable<TEntity> GetList()
    {
        return this._dataStoreStrategy.GetList();
    }

    //public T Last(Expression<Func<T, bool>> where)
    //{
    //    return this._dataStoreStrategy.Last(where);
    //}

    public void Remove(TEntity entity, bool SaveChanges = true)
    {
        this._dataStoreStrategy.Remove(entity, SaveChanges);
    }

    public async Task RemoveAsync(TEntity entity, bool SaveChanges = true)
    {
       await this.RemoveAsync(entity,SaveChanges);
    }

    public void RemoveRange(IEnumerable<TEntity> entities, bool SaveChanges = true)
    {
        this._dataStoreStrategy.RemoveRange(entities, SaveChanges);
    }

    public async Task RemoveRangeAsync(IEnumerable<TEntity> entities, bool SaveChanges = true)
    {
       await this._dataStoreStrategy.RemoveRangeAsync(entities, SaveChanges);
    }

    public void Save()
    {

        this._dataStoreStrategy.Save();
    }

    public async Task SaveAsync()
    {
       await this._dataStoreStrategy.SaveAsync();
    }

    public TEntity Single(Expression<Func<TEntity, bool>> where)
    {
       return this._dataStoreStrategy.Single(where);
    }

    public async Task<TEntity> SingleAsync(Expression<Func<TEntity, bool>> where)
    {
        return await this._dataStoreStrategy.SingleAsync(where);
    }

    public void Update(TEntity entity, bool SaveChanges = true)
    {
        this._dataStoreStrategy.Update(entity, SaveChanges);
    }

    public async Task UpdateAsync(TEntity entity, bool SaveChanges = true)
    {
      await  this._dataStoreStrategy.UpdateAsync(entity, SaveChanges);
    }
    internal CaliberMatrixEntities ctx { get { return _dataStoreStrategy.ctx as CaliberMatrixEntities; } }
    public virtual IQueryable<TEntity> GetAll() { return null; }
    public virtual TEntity Get(long id) { return null; }
    public virtual void Delete(long id) { }
    public virtual void Change(TEntity t, Guid by) { }
    public virtual void Add(TEntity t, Guid by) { }
    public virtual void AddRange(List<TEntity> t) { }
    public virtual void DeleteRange(List<int> t) { }
}