C# IUnitOfWork、IRepository 和 IMemoryCache [ASP.Net 核心]

Question

我的目标是缓存我的数据。我使用AspBoilerPlate 作为我代码的灵感来源。

我的 WebApi 使用 Asp.net Core。

GitHub

我在我的 GitHub 上创建了一个分支以获取更多详细信息：

• CacheRepository
• CacheUnitOfWork

CacheRepository

public class CacheRepository<TEntity, TPrimaryKey> : Repository<TEntity, TPrimaryKey>, ICacheRepository<TEntity, TPrimaryKey>
  where TEntity : class, IEntity<TPrimaryKey>
{
    private readonly IMemoryCache _memoryCache;

    public CacheRepository(DbContext dbContext, IMemoryCache memoryCache)
        : base(dbContext)
    {
        _memoryCache = memoryCache;
    }

    public override TEntity FirstOrDefault(TPrimaryKey id)
    {
        if (!_memoryCache.TryGetValue(GetCacheKey(id), out TEntity result))
        {
            result = base.FirstOrDefault(id);
            if (result != null)
            {
                PutInCache(result);
            }
        }

        return result;
    }

    public override void Delete(Expression<Func<TEntity, bool>> predicate)
    {
        foreach (var entity in GetAll().Where(predicate).ToList())
        {
            Delete(entity);
        }
    }

    public override void Delete(TEntity entity)
    {
        base.Delete(entity);
        RemoveFromCache(entity.Id);
    }

    public override void Delete(TPrimaryKey id)
    {
        base.Delete(id);
        RemoveFromCache(id);
    }

    public override Task DeleteAsync(Expression<Func<TEntity, bool>> predicate)
    {
        return Task.Run(() => Delete(predicate));
    }

    public override Task DeleteAsync(TEntity entity)
    {
        return Task.Run(() => Delete(entity));
    }

    public override Task DeleteAsync(TPrimaryKey id)
    {
        return Task.Run(() => Delete(id));
    }

    public override Task<TEntity> FirstOrDefaultAsync(TPrimaryKey id)
    {
        return _memoryCache.GetOrCreateAsync(
            GetCacheKey(id),
            e => base.FirstOrDefaultAsync(id)
        );
    }

    public override List<TEntity> GetAllList()
    {
        var entities = GetAllEntitiesFromCache();
        if (entities == null)
        {
            entities = base.GetAllList();
            foreach (var entity in entities)
            {
                PutInCache(entity);
            }
        }

        return entities.ToList();
    }

    public override async Task<List<TEntity>> GetAllListAsync()
    {
        var entities = GetAllEntitiesFromCache();
        if (entities == null)
        {
            entities = await base.GetAllListAsync();
            foreach (var entity in entities)
            {
                PutInCache(entity);
            }
        }

        return entities.ToList();
    }

    public override TEntity Get(TPrimaryKey id)
    {
        return _memoryCache.GetOrCreate(
            GetCacheKey(id),
            e => base.Get(id)
        );
    }

    public override Task<TEntity> GetAsync(TPrimaryKey id)
    {
        return _memoryCache.GetOrCreate(
            GetCacheKey(id),
            e => base.GetAsync(id)
        );
    }

    public override TEntity Insert(TEntity entity)
    {
        return PutInCache(base.Insert(entity));
    }

    public override TPrimaryKey InsertAndGetId(TEntity entity)
    {
        return Insert(entity).Id;
    }

    public override Task<TPrimaryKey> InsertAndGetIdAsync(TEntity entity)
    {
        return Task.FromResult(InsertAndGetId(entity));
    }

    public override Task<TEntity> InsertAsync(TEntity entity)
    {
        return Task.FromResult(Insert(entity));
    }

    public override TEntity Update(TEntity entity)
    {
        return UpdateInCache(base.Update(entity));
    }

    public override TEntity Update(TPrimaryKey id, Action<TEntity> updateAction)
    {
        return UpdateInCache(base.Update(id, updateAction));
    }

    public override Task<TEntity> UpdateAsync(TEntity entity)
    {
        return Task.FromResult(Update(entity));
    }

    public override async Task<TEntity> UpdateAsync(TPrimaryKey id, Func<TEntity, Task> updateAction)
    {
        return UpdateInCache(await base.UpdateAsync(id, updateAction));
    }

    #region Private

    private TEntity PutInCache(TEntity entity)
    {
        return _memoryCache.Set(GetCacheKey(entity.Id), entity);
    }

    private void RemoveFromCache(TPrimaryKey id)
    {
        _memoryCache.Remove(GetCacheKey(id));
    }

    private TEntity UpdateInCache(TEntity entity)
    {
        RemoveFromCache(entity.Id);
        return PutInCache(entity);
    }



    private string GetCacheKey(TPrimaryKey id)
    {
        return typeof(TEntity).FullName + id;
    }

    private IList<TEntity> GetAllEntitiesFromCache()
    {
        return _memoryCache.Get<List<TEntity>>(typeof(TEntity));
    }
    #endregion
}

我的问题：

我有很多关于我的 CacheRepository 的问题要问，但我必须减少它才能发布我的帖子。

=> 在 UnitOfWork.SubmitChanges 之前的 Insert/Edit/Delete 上直接在 CacheRepository 中添加/编辑/删除是不是一件好事？

如果您对 CacheRepository 有任何建议或建议，请分享，我真的很想了解更多。

Answer 1

通常在进程未完成时从缓存中删除某些内容可能会导致问题。尚不确定更改是否会生效，因为即使使用 orm，您的 dbms 也会为您做出决定。您最终将深入挖掘所有异常并读取内容，而您本可以等待进程完成，然后再从给定缓存中删除对象。

当我深入研究您的代码（非常干净，为此 +1）时，我想到的其他事情如下

1. Generic-Repository-Pattern 是 anti-pattern。我也喜欢将它用于简单的场景，但这并不是必需的。
2. 您的CacheRepository 现在不仅负责缓存，还负责对数据库的CRUD 操作。这违反了SRP。
3. CacheUnitOfWork 不仅是一个缓存和一个工作单元，它还是一个工厂、一个存储库以及已经实现的功能之上的另一层。同样，这违反了 SRP。
4. IMemoryCache is part of a library the belongs to AspNetCore。您在自己的实现中使用它，而它已经包装了将内容放入并发字典的逻辑。您可以简单地在控制器中使用它，必要时在您的操作中添加/更新或删除项目。
5. 工作单元模式in this scenario is not necessary。使用您的 db-context 时，您在使用 context.Set<TEnitity>()... 以及将所有内容包装在存储库中时已经拥有它。

抽象是好事，但有时也可能很糟糕。

我知道其中的困难，这就是为什么我阅读了很多关于这些问题的文章并找到了一个很好的解决方案。 CQRS，中介和类似 DDD 的服务。

我还建议您查看AutoFac for IoC and DI。你现在手动做的很多事情（比如创建类型的工厂），可以使用它的assembly scanning 自动完成。它甚至可以与.NET Core native IoC 集成。

希望它可以帮助您获得一些想法。