Redis結合EntityFramework結合使用的操作類


最近一段時間在研究redis。  各種不懂, 各種問題。也看了N多的資料。  

最終參照着  張占嶺 的博客  http://www.cnblogs.com/lori/p/3435483.html   寫了一套redis與entityframework結合的操作類。

如有什么不正確的地方,請指明。  

 

 

 

using ServiceStack.Redis;
using ServiceStack.Redis.Generic;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.Entity;
using System.Threading.Tasks;
using System.Linq.Expressions;
using ServiceStack.Redis.Pipeline;
using ServiceStack.Redis.Support;
using System.Data.SqlClient;
namespace Redis
{

  /// <summary>
  /// 操作redis與entity framework
  /// </summary>
  public class RedisRepository<TEntity> :
      IDisposable
      where TEntity : class
  {
    public DbContext context;
    IRedisClient redisDB;
    IRedisTypedClient<TEntity> redisTypedClient;
    IRedisList<TEntity> table;

    public RedisRepository(DbContext context)
    {
      this.context = context;
      redisDB = new RedisClient("192.168.2.47", 6379);//redis服務IP和端口
      redisTypedClient = redisDB.As<TEntity>();
      table = redisTypedClient.Lists[typeof(TEntity).Name];
    }



    #region Repository<TEntity>成員

    /// <summary>
    /// 添加一條數據,該操作會同時插入到mssql和redis
    /// </summary>
    /// <param name="item">數據模型</param>
    /// <returns>是否成功,成功返回1,失敗返回0</returns>
    public int Insert(TEntity item)
    {
      int result = 0;
      if (item != null)
      {
        context.Set<TEntity>().Add(item);
        result = context.SaveChanges();
        if (result > 0)
        {
          Task.Run(async () => await AsyncAddEntity(item));//異步向redis插入數據。
        }
      }
      return result;
    }

    /// <summary>
    /// 刪除單條數據操作,同時刪除redis和SqlServer
    /// </summary>
    /// <param name="keysValue">刪除條件</param>
    /// <returns>是否成功,成功返回1,失敗返回0</returns>
    public int Delete(params object[] keysValue)
    {
      var entity = context.Set<TEntity>().Find(keysValue);
      context.Set<TEntity>().Remove(entity);
      int result = context.SaveChanges();
      if (result > 0)
      {
        Task.Run(async () => await AsyncDelEntity(entity));//異步刪除一條數據
      }
      return result;
    }

    /// <summary>
    /// 修改操作,同時修改SqlServer和redis
    /// </summary>
    /// <param name="itemOld">舊數據</param>
    /// <param name="item">新數據</param>
    /// <returns>是否成功,成功返回1,失敗返回0</returns>
    public int Update(Func<TEntity, bool> func, TEntity item)
    {
      context.Entry<TEntity>(item).State = EntityState.Modified;
      int result = context.SaveChanges();
      if (result > 0)
      {
        Task.Run(async () => await AsyncEditEntity(func, item));//異步修改redis數據。
      }
      return result;
    }

    /// <summary>
    /// 批量刪除數據 ,同時刪除redis和SqlServer
    /// </summary>
    /// <param name="func">刪除條件</param>
    /// <returns>返回刪除成功的行數</returns>
    public int DeleteSelect(Func<TEntity, bool> func)
    {
      var entities = context.Set<TEntity>().Where(func);
      context.Set<TEntity>().RemoveRange(entities);
      int result = context.SaveChanges();
      if (result > 0)
      {
        Task.Run(async () => await AsyncDelEntity(func));//異步刪除redis數據。
      }
      return result;
    }

    /// <summary>
    /// 獲取所有數據
    /// </summary>
    /// <returns></returns>
    public IQueryable<TEntity> GetModel()
    {
      return table.GetAll().AsQueryable();
    }

    /// <summary>
    /// 獲取分頁數據
    /// </summary>
    /// <param name="func">查詢條件</param>
    /// <param name="keySelector">排序字段</param>
    /// <param name="pageIndex">獲取頁面的頁數</param>
    /// <param name="pageSize">頁面行數</param>
    /// <param name="totalPage">返回數據行總數</param>
    /// <returns></returns>
    public IList<TEntity> GetModel(Func<TEntity, bool> func, Func<TEntity, object> keySelector, int pageIndex, int pageSize, out int totalPage)
    {
      int startRow = (pageIndex - 1) * pageSize;
      totalPage = table.Count();
      //判斷緩存中數據是否為空並且數據庫內數據行數是否與緩存中行數一致,如果為空或者不一致  從數據庫查詢數據 異步插入到緩存中。
      int dbCount = context.Set<TEntity>().Count();
      if (dbCount != totalPage || totalPage == 0)
      {
        totalPage = dbCount;
        List<TEntity> listDB = context.Set<TEntity>().AsQueryable().ToList();
        Task.Run(async () => await AsyncAddEntity(listDB));//異步向redis插入數據。
        return context.Set<TEntity>().AsQueryable().Where(func).OrderBy(keySelector).Skip(startRow).Take(pageSize).ToList();
      }
      return table.GetAll().AsQueryable().Where(func).OrderBy(keySelector).Skip(startRow).Take(pageSize).ToList();
    }

    /// <summary>
    /// 查詢單條數據
    /// </summary>
    /// <param name="func">查詢條件</param>
    /// <returns></returns>
    public TEntity Find(Func<TEntity, bool> func)
    {
      return table.Where(func).FirstOrDefault();
    }

    /// <summary>
    /// 異步插入到redis列表
    /// </summary>
    /// <param name="listDB"></param>
    /// <returns></returns>
    private Task AsyncAddEntity(List<TEntity> listDB)
    {
      return Task.Factory.StartNew(() =>
      {
        table.RemoveAll();
        listDB.ForEach(m => redisTypedClient.AddItemToList(table, m));
        redisDB.Save();
      });
    }

    /// <summary>
    ///  異步插入到redis單條
    /// </summary>
    /// <param name="entity"></param>
    /// <returns></returns>
    private Task AsyncAddEntity(TEntity entity)
    {
      return Task.Factory.StartNew(() =>
      {
        redisTypedClient.AddItemToList(table, entity);
        redisDB.Save();
      });
    }

    /// <summary>
    /// 異步刪除一條數據
    /// </summary>
    /// <param name="entity"></param>
    /// <returns></returns>
    private Task AsyncDelEntity(TEntity entity)
    {
      return Task.Factory.StartNew(() =>
      {
        redisTypedClient.RemoveItemFromList(table, entity);
        redisDB.Save();
      });
    }
    private Task AsyncDelEntity(Func<TEntity, bool> func)
    {
      return Task.Factory.StartNew(() =>
      {
        table.GetAll().AsQueryable().Where(func).ToList().ForEach(m => redisTypedClient.RemoveItemFromList(table, m));
        redisDB.Save();
      });
    }
    /// <summary>
    /// 修改一條數據
    /// </summary>
    /// <param name="func"></param>
    /// <param name="item"></param>
    /// <returns></returns>
    private Task AsyncEditEntity(Func<TEntity, bool> func, TEntity item)
    {
      return Task.Factory.StartNew(() =>
      {
        redisTypedClient.RemoveItemFromList(table, Find(func));
        redisTypedClient.AddItemToList(table, item);
        redisDB.Save();
      });
    }


    #endregion

    #region IDisposable成員
    public void Dispose()
    {
      this.ExplicitDispose();
    }
    #endregion

    #region Protected Methods


    /// <summary>
    /// 垃圾回收
    /// </summary>
    protected void ExplicitDispose()
    {
      this.Dispose(true);
      GC.SuppressFinalize(this);
    }

    protected void Dispose(bool disposing)
    {
      if (disposing)//清除非托管資源
      {
        table = null;
        redisTypedClient = null;
        redisDB.Dispose();
      }
    }
    #endregion

    #region Finalization Constructs
    /// <summary>
    /// Finalizes the object.
    /// </summary>
    ~RedisRepository()
    {
      this.Dispose(false);
    }
    #endregion
  }
}

 


免責聲明!

本站轉載的文章為個人學習借鑒使用,本站對版權不負任何法律責任。如果侵犯了您的隱私權益,請聯系本站郵箱yoyou2525@163.com刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM