using System;
using System.Linq;
using System.Threading.Tasks;
using System.Linq.Expressions;
using System.Collections.Generic;
using System.Data.Entity;
using System.Data.Entity.Migrations;
using FantasyCMS.IDAL;
 
 
namespace FantasyCMS.DAL
{
    public class BaseRepository<TEntity> : InterfaceBaseRepository<TEntity> where TEntity : class
    {
        protected DBContext nContext = ContextFactory.GetCurentContext();
 
 
        public virtual IQueryable<TEntity> FindList<S>(Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, S>> orderLambda, bool isAsc)
        {
            var _list = nContext.Set<TEntity>().Where<TEntity>(whereLambda);
            if (isAsc) _list = _list.OrderBy<TEntity, S>(orderLambda);
            else _list = _list.OrderByDescending<TEntity, S>(orderLambda);
            return _list;
        }
 
 
        public virtual IQueryable<TEntity> FindPageList<S>(Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, S>> orderLambda, bool isAsc, int page, int pageSize)
        {
            var _list = nContext.Set<TEntity>().Where<TEntity>(whereLambda);
            if (isAsc) _list = _list.OrderBy<TEntity, S>(orderLambda);
            else _list = _list.OrderByDescending<TEntity, S>(orderLambda);
            _list = _list.Skip(pageSize * (page - 1)).Take(pageSize);
            return _list;
        }
 
 
        //6.0
 
 
        /// <summary>
        /// 建立一個原始 SQL 查詢，該查詢將返回此集中的實體。 預設情況下，上下文會跟蹤返回的實體；可通過對返回的 DbSqlQuery<TEntity> 呼叫 AsNoTracking 來更改此設定。 請注意返回實體的型別始終是此集的型別，而不會是派生的型別。 如果查詢的一個或多個表可能包含其他實體型別的資料，則必須編寫適當的 SQL 查詢以確保只返回適當型別的實體。 與接受 SQL 的任何 API 一樣，對任何使用者輸入進行引數化以便避免 SQL 注入攻擊是十分重要的。 您可以在 SQL 查詢字串中包含引數佔位符，然後將引數值作為附加引數提供。 您提供的任何引數值都將自動轉換為 DbParameter。 context.Blogs.SqlQuery("SELECT * FROM dbo.Posts WHERE Author = @p0", userSuppliedAuthor); 或者，您還可以構造一個 DbParameter 並將它提供給 SqlQuery。 這允許您在 SQL 查詢字串中使用命名引數。 context.Blogs.SqlQuery("SELECT * FROM dbo.Posts WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor));
        /// </summary>
        /// <param name="sql">sql查詢語句</param>
        public virtual IEnumerable<TEntity> SqlQuery(string sql)
        {
            return nContext.Database.SqlQuery<TEntity>(sql);
        }
 
 
        /// <summary>
        /// 對資料庫執行給定的 DDL/DML 命令。 與接受 SQL 的任何 API 一樣，對任何使用者輸入進行引數化以便避免 SQL 注入攻擊是十分重要的。 您可以在 SQL 查詢字串中包含引數佔位符，然後將引數值作為附加引數提供。 您提供的任何引數值都將自動轉換為 DbParameter。 context.Database.ExecuteSqlCommand("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @p0", userSuppliedAuthor); 或者，您還可以構造一個 DbParameter 並將它提供給 SqlQuery。 這允許您在 SQL 查詢字串中使用命名引數。 context.Database.ExecuteSqlCommand("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor));
        /// </summary>
        /// <param name="sql">查詢語句</param>
        /// <returns></returns>
        public virtual bool ExecuteSqlCommand(string sql)
        {
            return nContext.Database.ExecuteSqlCommand(sql) > 0;
        }
 
 
        /// <summary>
        /// 非同步對資料庫執行給定的 DDL/DML 命令。 與接受 SQL 的任何 API 一樣，對任何使用者輸入進行引數化以便避免 SQL 注入攻擊是十分重要的。 您可以在 SQL 查詢字串中包含引數佔位符，然後將引數值作為附加引數提供。 您提供的任何引數值都將自動轉換為 DbParameter。 context.Database.ExecuteSqlCommand("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @p0", userSuppliedAuthor); 或者，您還可以構造一個 DbParameter 並將它提供給 SqlQuery。 這允許您在 SQL 查詢字串中使用命名引數。 context.Database.ExecuteSqlCommand("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor));
        /// </summary>
        /// <param name="sql">查詢語句</param>
        /// <returns></returns>
        public virtual async Task<bool> ExcuteSqlCommandAsync(string sql)
        {
            return await nContext.Database.ExecuteSqlCommandAsync(sql) > 0;
        }
 
 
        /// <summary>
        /// 將給定實體以“已新增”狀態新增到集的基礎上下文中，這樣一來，當呼叫 SaveChanges 時，會將該實體插入到資料庫中。
        /// </summary>
        /// <param name="entity">實體</param>
        /// <returns></returns>
        public virtual bool Add(TEntity entity)
        {
            nContext.Set<TEntity>().Add(entity);
            return nContext.SaveChanges() > 0;
        }
 
 
        /// <summary>
        /// 非同步將給定實體以“已新增”狀態新增到集的基礎上下文中，這樣一來，當呼叫 SaveChanges 時，會將該實體插入到資料庫中。
        /// </summary>
        /// <param name="entity">實體</param>
        /// <returns></returns>
        public virtual async Task<bool> AddAsync(TEntity entity)
        {
            nContext.Set<TEntity>().Add(entity);
            return await nContext.SaveChangesAsync() > 0;
        }
 
 
        /// <summary>
        /// 將給定實體集合新增到基礎化集的上下文中（每個實體都置於“已新增”狀態），這樣當呼叫 SaveChanges 時，會將它插入到資料庫中。
        /// </summary>
        /// <param name="entities">合集</param>
        /// <returns></returns>
        public virtual bool AddRange(IEnumerable<TEntity> entities)
        {
            nContext.Set<TEntity>().AddRange(entities);
            return nContext.SaveChanges() > 0;
        }
 
 
        /// <summary>
        /// 非同步將給定實體集合新增到基礎化集的上下文中（每個實體都置於“已新增”狀態），這樣當呼叫 SaveChanges 時，會將它插入到資料庫中。
        /// </summary>
        /// <param name="entities">合集</param>
        /// <returns></returns>
        public virtual async Task<bool> AddRangeAsync(IEnumerable<TEntity> entities)
        {
            nContext.Set<TEntity>().AddRange(entities);
            return await nContext.SaveChangesAsync() > 0;
        }
 
 
        /// <summary>
        /// 將給定實體標記為“已刪除”，這樣一來，當呼叫 SaveChanges 時，將從資料庫中刪除該實體。 請注意，在呼叫此方法之前，該實體必須以另一種狀態存在於該上下文中。
        /// </summary>
        /// <param name="entity">實體</param>
        /// <returns></returns>
        public virtual bool Remove(TEntity entity)
        {
            nContext.Set<TEntity>().Remove(entity);
            return nContext.SaveChanges() > 0;
        }
 
 
        /// <summary>
        /// 非同步將給定實體標記為“已刪除”，這樣一來，當呼叫 SaveChanges 時，將從資料庫中刪除該實體。 請注意，在呼叫此方法之前，該實體必須以另一種狀態存在於該上下文中。
        /// </summary>
        /// <param name="entity">實體</param>
        /// <returns></returns>
        public virtual async Task<bool> RemoveAsync(TEntity entity)
        {
            nContext.Set<TEntity>().Remove(entity);
            return await nContext.SaveChangesAsync() > 0;
        }
 
 
        /// <summary>
        /// 從基礎化集的上下文中刪除給定實體集合（每個實體都置於“已刪除”狀態），這樣當呼叫 SaveChanges 時，會從資料庫中刪除它。
        /// </summary>
        /// <param name="entities">合集</param>
        /// <returns></returns>
        public virtual bool RemoveRange(IEnumerable<TEntity> entities)
        {
            nContext.Set<TEntity>().RemoveRange(entities);
            return nContext.SaveChanges() > 0;
        }
 
 
        /// <summary>
        /// 非同步從基礎化集的上下文中刪除給定實體集合（每個實體都置於“已刪除”狀態），這樣當呼叫 SaveChanges 時，會從資料庫中刪除它。
        /// </summary>
        /// <param name="entities">合集</param>
        /// <returns></returns>
        public virtual async Task<bool> RemoveRangeAsync(IEnumerable<TEntity> entities)
        {
            nContext.Set<TEntity>().RemoveRange(entities);
            return await nContext.SaveChangesAsync() > 0;
        }
 
 
        /// <summary>
        /// 過載。 呼叫 SaveChanges 時，按鍵新增或更新實體。 等效於資料庫術語中的“upsert”操作。 此方法在使用遷移設定資料的種子時很有用。 （由 DbSetMigrationsExtensions 定義。）
        /// </summary>
        /// <param name="entity">實體</param>
        /// <returns></returns>
        public virtual bool AddOrUpdate(TEntity entity)
        {
            nContext.Set<TEntity>().AddOrUpdate(entity);
            return nContext.SaveChanges() > 0;
        }
 
 
        /// <summary>
        /// 過載。 非同步呼叫 SaveChanges 時，按鍵新增或更新實體。 等效於資料庫術語中的“upsert”操作。 此方法在使用遷移設定資料的種子時很有用。 （由 DbSetMigrationsExtensions 定義。）
        /// </summary>
        /// <param name="entity">實體</param>
        /// <returns></returns>
        public virtual async Task<bool> AddOrUpdateAsync(TEntity entity)
        {
            nContext.Set<TEntity>().AddOrUpdate(entity);
            return await nContext.SaveChangesAsync() > 0;
        }
 
 
        /// <summary>
        /// 過載。 確定序列的任何元素是否滿足條件。 （由 QueryableExtensions 定義。）
        /// </summary>
        /// <param name="anyLambda"></param>
        /// <returns></returns>
        public virtual bool Exists(Expression<Func<TEntity, bool>> anyLambda)
        {
            return nContext.Set<TEntity>().Any(anyLambda);
        }
 
 
        /// <summary>
        /// 過載。 非同步確定序列的任何元素是否滿足條件。 （由 QueryableExtensions 定義。）
        /// </summary>
        /// <param name="anyLambda"></param>
        /// <returns></returns>
        public virtual async Task<bool> ExistsAsync(Expression<Func<TEntity, Boolean>> anyLambda)
        {
            return await nContext.Set<TEntity>().AnyAsync(anyLambda);
        }
 
 
        /// <summary>
        /// 查詢帶給定主鍵值的實體。 如果上下文中存在帶給定主鍵值的實體，則立即返回該實體，而不會向儲存區傳送請求。 否則，會向儲存區傳送查詢帶給定主鍵值的實體的請求，如果找到該實體，則將其附加到上下文並返回。 如果未在上下文或儲存區中找到實體，則返回 null。
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public virtual TEntity Find(object key)
        {
            return nContext.Set<TEntity>().Find(key);
        }
 
 
        /// <summary>
        /// 非同步查詢帶給定主鍵值的實體。 如果上下文中存在帶給定主鍵值的實體，則立即返回該實體，而不會向儲存區傳送請求。 否則，會向儲存區傳送查詢帶給定主鍵值的實體的請求，如果找到該實體，則將其附加到上下文並返回。 如果未在上下文或儲存區中找到實體，則返回 null。
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public virtual async Task<TEntity> FindAsync(object key)
        {
            return await nContext.Set<TEntity>().FindAsync(key);
        }
 
 
        /// <summary>
        /// 過載。 非同步返回序列的第一個元素。
        /// </summary>
        /// <param name="whereLambda">查詢表示式</param>
        /// <returns></returns>
        public virtual TEntity Find(Expression<Func<TEntity, bool>> whereLambda)
        {
            return nContext.Set<TEntity>().FirstOrDefault<TEntity>(whereLambda);
        }
 
 
        /// <summary>
        /// 過載。 非同步返回序列的第一個元素。
        /// </summary>
        /// <param name="whereLambda">查詢表示式</param>
        /// <returns></returns>
        public virtual async Task<TEntity> FindAsync(Expression<Func<TEntity, bool>> whereLambda)
        {
            return await nContext.Set<TEntity>().FirstOrDefaultAsync<TEntity>(whereLambda);
        }
 
 
        /// <summary>
        /// 過載。 非同步列舉查詢結果並對每個元素執行指定的操作。 （由 QueryableExtensions 定義。）
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public virtual async Task ForeachAsync(Action<TEntity> obj)
        {
            await nContext.Set<TEntity>().ForEachAsync(obj);
        }
 
 
        /// <summary>
        /// 過載。 返回序列中的元素數。 （由 QueryableExtensions 定義。）
        /// </summary>
        /// <returns></returns>
        public virtual int Count()
        {
            return nContext.Set<TEntity>().Count();
        }
 
 
        /// <summary>
        /// 過載。 非同步返回序列中的元素數。 （由 QueryableExtensions 定義。）
        /// </summary>
        /// <returns></returns>
        public virtual async Task<int> CountAsync()
        {
            return await nContext.Set<TEntity>().CountAsync();
        }
 
 
        /// <summary>
        /// 過載。 返回滿足條件的序列中的元素數。
        /// </summary>
        /// <param name="predicate">查詢表示式</param>
        /// <returns></returns>
        public virtual int Count(Expression<Func<TEntity, bool>> predicate)
        {
            return nContext.Set<TEntity>().Count(predicate);
        }
 
 
        /// <summary>
        /// 過載。 返回滿足條件的序列中的元素數。
        /// </summary>
        /// <param name="predicate">查詢表示式</param>
        /// <returns></returns>
        public virtual async Task<int> CountAsync(Expression<Func<TEntity, bool>> predicate)
        {
            return await nContext.Set<TEntity>().CountAsync(predicate);
        }
    }
}
 

原文：點選開啟連結