zoukankan      html  css  js  c++  java

  • EF6增改删等常用基类

    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;  
        }
  
        /// <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);  
        }  
    }  
}

    　　

    1. using System;  
    2. using System.Linq;  
    3. using System.Threading.Tasks;  
    4. using System.Linq.Expressions;  
    5. using System.Collections.Generic;  
    6. using System.Data.Entity;  
    7. using System.Data.Entity.Migrations;  
    8. using FantasyCMS.IDAL;  
    9.   
    10.   
    11. namespace FantasyCMS.DAL  
    12. {  
    13.     public class BaseRepository<TEntity> : InterfaceBaseRepository<TEntity> where TEntity : class  
    14.     {  
    15.         protected DBContext nContext = ContextFactory.GetCurentContext();  
    16.   
    17.   
    18.         public virtual IQueryable<TEntity> FindList<S>(Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, S>> orderLambda, bool isAsc)  
    19.         {  
    20.             var _list = nContext.Set<TEntity>().Where<TEntity>(whereLambda);  
    21.             if (isAsc) _list = _list.OrderBy<TEntity, S>(orderLambda);  
    22.             else _list = _list.OrderByDescending<TEntity, S>(orderLambda);  
    23.             return _list;  
    24.         }  
    25.   
    26.   
    27.         public virtual IQueryable<TEntity> FindPageList<S>(Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, S>> orderLambda, bool isAsc, int page, int pageSize)  
    28.         {  
    29.             var _list = nContext.Set<TEntity>().Where<TEntity>(whereLambda);  
    30.             if (isAsc) _list = _list.OrderBy<TEntity, S>(orderLambda);  
    31.             else _list = _list.OrderByDescending<TEntity, S>(orderLambda);  
    32.             _list = _list.Skip(pageSize * (page - 1)).Take(pageSize);  
    33.             return _list;  
    34.         }  
    35.   
    36.   
    37.         //6.0  
    38.   
    39.   
    40.         /// <summary>  
    41.         /// 创建一个原始 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));  
    42.         /// </summary>  
    43.         /// <param name="sql">sql查询语句</param>  
    44.         public virtual IEnumerable<TEntity> SqlQuery(string sql)  
    45.         {  
    46.             return nContext.Database.SqlQuery<TEntity>(sql);  
    47.         }  
    48.   
    49.   
    50.         /// <summary>  
    51.         /// 对数据库执行给定的 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));  
    52.         /// </summary>  
    53.         /// <param name="sql">查询语句</param>  
    54.         /// <returns></returns>  
    55.         public virtual bool ExecuteSqlCommand(string sql)  
    56.         {  
    57.             return nContext.Database.ExecuteSqlCommand(sql) > 0;  
    58.         }  
    59.   
    60.   
    61.         /// <summary>  
    62.         /// 异步对数据库执行给定的 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));  
    63.         /// </summary>  
    64.         /// <param name="sql">查询语句</param>  
    65.         /// <returns></returns>  
    66.         public virtual async Task<bool> ExcuteSqlCommandAsync(string sql)  
    67.         {  
    68.             return await nContext.Database.ExecuteSqlCommandAsync(sql) > 0;  
    69.         }  
    70.   
    71.   
    72.         /// <summary>  
    73.         /// 将给定实体以“已添加”状态添加到集的基础上下文中，这样一来，当调用 SaveChanges 时，会将该实体插入到数据库中。  
    74.         /// </summary>  
    75.         /// <param name="entity">实体</param>  
    76.         /// <returns></returns>  
    77.         public virtual bool Add(TEntity entity)  
    78.         {  
    79.             nContext.Set<TEntity>().Add(entity);  
    80.             return nContext.SaveChanges() > 0;  
    81.         }  
    82.   
    83.   
    84.         /// <summary>  
    85.         /// 异步将给定实体以“已添加”状态添加到集的基础上下文中，这样一来，当调用 SaveChanges 时，会将该实体插入到数据库中。  
    86.         /// </summary>  
    87.         /// <param name="entity">实体</param>  
    88.         /// <returns></returns>  
    89.         public virtual async Task<bool> AddAsync(TEntity entity)  
    90.         {  
    91.             nContext.Set<TEntity>().Add(entity);  
    92.             return await nContext.SaveChangesAsync() > 0;  
    93.         }  
    94.   
    95.   
    96.         /// <summary>  
    97.         /// 将给定实体集合添加到基础化集的上下文中（每个实体都置于“已添加”状态），这样当调用 SaveChanges 时，会将它插入到数据库中。  
    98.         /// </summary>  
    99.         /// <param name="entities">合集</param>  
    100.         /// <returns></returns>  
    101.         public virtual bool AddRange(IEnumerable<TEntity> entities)  
    102.         {  
    103.             nContext.Set<TEntity>().AddRange(entities);  
    104.             return nContext.SaveChanges() > 0;  
    105.         }  
    106.   
    107.   
    108.         /// <summary>  
    109.         /// 异步将给定实体集合添加到基础化集的上下文中（每个实体都置于“已添加”状态），这样当调用 SaveChanges 时，会将它插入到数据库中。  
    110.         /// </summary>  
    111.         /// <param name="entities">合集</param>  
    112.         /// <returns></returns>  
    113.         public virtual async Task<bool> AddRangeAsync(IEnumerable<TEntity> entities)  
    114.         {  
    115.             nContext.Set<TEntity>().AddRange(entities);  
    116.             return await nContext.SaveChangesAsync() > 0;  
    117.         }  
    118.   
    119.   
    120.         /// <summary>  
    121.         /// 将给定实体标记为“已删除”，这样一来，当调用 SaveChanges 时，将从数据库中删除该实体。 请注意，在调用此方法之前，该实体必须以另一种状态存在于该上下文中。  
    122.         /// </summary>  
    123.         /// <param name="entity">实体</param>  
    124.         /// <returns></returns>  
    125.         public virtual bool Remove(TEntity entity)  
    126.         {  
    127.             nContext.Set<TEntity>().Remove(entity);  
    128.             return nContext.SaveChanges() > 0;  
    129.         }  
    130.   
    131.   
    132.         /// <summary>  
    133.         /// 异步将给定实体标记为“已删除”，这样一来，当调用 SaveChanges 时，将从数据库中删除该实体。 请注意，在调用此方法之前，该实体必须以另一种状态存在于该上下文中。  
    134.         /// </summary>  
    135.         /// <param name="entity">实体</param>  
    136.         /// <returns></returns>  
    137.         public virtual async Task<bool> RemoveAsync(TEntity entity)  
    138.         {  
    139.             nContext.Set<TEntity>().Remove(entity);  
    140.             return await nContext.SaveChangesAsync() > 0;  
    141.         }  
    142.   
    143.   
    144.         /// <summary>  
    145.         /// 从基础化集的上下文中删除给定实体集合（每个实体都置于“已删除”状态），这样当调用 SaveChanges 时，会从数据库中删除它。  
    146.         /// </summary>  
    147.         /// <param name="entities">合集</param>  
    148.         /// <returns></returns>  
    149.         public virtual bool RemoveRange(IEnumerable<TEntity> entities)  
    150.         {  
    151.             nContext.Set<TEntity>().RemoveRange(entities);  
    152.             return nContext.SaveChanges() > 0;  
    153.         }  
    154.   
    155.   
    156.         /// <summary>  
    157.         /// 异步从基础化集的上下文中删除给定实体集合（每个实体都置于“已删除”状态），这样当调用 SaveChanges 时，会从数据库中删除它。  
    158.         /// </summary>  
    159.         /// <param name="entities">合集</param>  
    160.         /// <returns></returns>  
    161.         public virtual async Task<bool> RemoveRangeAsync(IEnumerable<TEntity> entities)  
    162.         {  
    163.             nContext.Set<TEntity>().RemoveRange(entities);  
    164.             return await nContext.SaveChangesAsync() > 0;  
    165.         }  
    166.   
    167.   
    168.         /// <summary>  
    169.         /// 重载。 调用 SaveChanges 时，按键添加或更新实体。 等效于数据库术语中的“upsert”操作。 此方法在使用迁移设置数据的种子时很有用。 （由 DbSetMigrationsExtensions 定义。）  
    170.         /// </summary>  
    171.         /// <param name="entity">实体</param>  
    172.         /// <returns></returns>  
    173.         public virtual bool AddOrUpdate(TEntity entity)  
    174.         {  
    175.             nContext.Set<TEntity>().AddOrUpdate(entity);  
    176.             return nContext.SaveChanges() > 0;  
    177.         }  
    178.   
    179.   
    180.         /// <summary>  
    181.         /// 重载。 异步调用 SaveChanges 时，按键添加或更新实体。 等效于数据库术语中的“upsert”操作。 此方法在使用迁移设置数据的种子时很有用。 （由 DbSetMigrationsExtensions 定义。）  
    182.         /// </summary>  
    183.         /// <param name="entity">实体</param>  
    184.         /// <returns></returns>  
    185.         public virtual async Task<bool> AddOrUpdateAsync(TEntity entity)  
    186.         {  
    187.             nContext.Set<TEntity>().AddOrUpdate(entity);  
    188.             return await nContext.SaveChangesAsync() > 0;  
    189.         }  
    190.   
    191.   
    192.         /// <summary>  
    193.         /// 重载。 确定序列的任何元素是否满足条件。 （由 QueryableExtensions 定义。）  
    194.         /// </summary>  
    195.         /// <param name="anyLambda"></param>  
    196.         /// <returns></returns>  
    197.         public virtual bool Exists(Expression<Func<TEntity, bool>> anyLambda)  
    198.         {  
    199.             return nContext.Set<TEntity>().Any(anyLambda);  
    200.         }  
    201.   
    202.   
    203.         /// <summary>  
    204.         /// 重载。 异步确定序列的任何元素是否满足条件。 （由 QueryableExtensions 定义。）  
    205.         /// </summary>  
    206.         /// <param name="anyLambda"></param>  
    207.         /// <returns></returns>  
    208.         public virtual async Task<bool> ExistsAsync(Expression<Func<TEntity, Boolean>> anyLambda)  
    209.         {  
    210.             return await nContext.Set<TEntity>().AnyAsync(anyLambda);  
    211.         }  
    212.   
    213.   
    214.         /// <summary>  
    215.         /// 查找带给定主键值的实体。 如果上下文中存在带给定主键值的实体，则立即返回该实体，而不会向存储区发送请求。 否则，会向存储区发送查找带给定主键值的实体的请求，如果找到该实体，则将其附加到上下文并返回。 如果未在上下文或存储区中找到实体，则返回 null。  
    216.         /// </summary>  
    217.         /// <param name="key"></param>  
    218.         /// <returns></returns>  
    219.         public virtual TEntity Find(object key)  
    220.         {  
    221.             return nContext.Set<TEntity>().Find(key);  
    222.         }  
    223.   
    224.   
    225.         /// <summary>  
    226.         /// 异步查找带给定主键值的实体。 如果上下文中存在带给定主键值的实体，则立即返回该实体，而不会向存储区发送请求。 否则，会向存储区发送查找带给定主键值的实体的请求，如果找到该实体，则将其附加到上下文并返回。 如果未在上下文或存储区中找到实体，则返回 null。  
    227.         /// </summary>  
    228.         /// <param name="key"></param>  
    229.         /// <returns></returns>  
    230.         public virtual async Task<TEntity> FindAsync(object key)  
    231.         {  
    232.             return await nContext.Set<TEntity>().FindAsync(key);  
    233.         }  
    234.   
    235.   
    236.         /// <summary>  
    237.         /// 重载。 异步返回序列的第一个元素。  
    238.         /// </summary>  
    239.         /// <param name="whereLambda">查询表达式</param>  
    240.         /// <returns></returns>  
    241.         public virtual TEntity Find(Expression<Func<TEntity, bool>> whereLambda)  
    242.         {  
    243.             return nContext.Set<TEntity>().FirstOrDefault<TEntity>(whereLambda);  
    244.         }  
    245.   
    246.   
    247.         /// <summary>  
    248.         /// 重载。 异步返回序列的第一个元素。  
    249.         /// </summary>  
    250.         /// <param name="whereLambda">查询表达式</param>  
    251.         /// <returns></returns>  
    252.         public virtual async Task<TEntity> FindAsync(Expression<Func<TEntity, bool>> whereLambda)  
    253.         {  
    254.             return await nContext.Set<TEntity>().FirstOrDefaultAsync<TEntity>(whereLambda);  
    255.         }  
    256.   
    257.   
    258.         /// <summary>  
    259.         /// 重载。 异步枚举查询结果并对每个元素执行指定的操作。 （由 QueryableExtensions 定义。）  
    260.         /// </summary>  
    261.         /// <param name="obj"></param>  
    262.         /// <returns></returns>  
    263.         public virtual async Task ForeachAsync(Action<TEntity> obj)  
    264.         {  
    265.             await nContext.Set<TEntity>().ForEachAsync(obj);  
    266.         }  
    267.   
    268.   
    269.         /// <summary>  
    270.         /// 重载。 返回序列中的元素数。 （由 QueryableExtensions 定义。）  
    271.         /// </summary>  
    272.         /// <returns></returns>  
    273.         public virtual int Count()  
    274.         {  
    275.             return nContext.Set<TEntity>().Count();  
    276.         }  
    277.   
    278.   
    279.         /// <summary>  
    280.         /// 重载。 异步返回序列中的元素数。 （由 QueryableExtensions 定义。）  
    281.         /// </summary>  
    282.         /// <returns></returns>  
    283.         public virtual async Task<int> CountAsync()  
    284.         {  
    285.             return await nContext.Set<TEntity>().CountAsync();  
    286.         }  
    287.   
    288.   
    289.         /// <summary>  
    290.         /// 重载。 返回满足条件的序列中的元素数。  
    291.         /// </summary>  
    292.         /// <param name="predicate">查询表达式</param>  
    293.         /// <returns></returns>  
    294.         public virtual int Count(Expression<Func<TEntity, bool>> predicate)  
    295.         {  
    296.             return nContext.Set<TEntity>().Count(predicate);  
    297.         }  
    298.   
    299.   
    300.         /// <summary>  
    301.         /// 重载。 返回满足条件的序列中的元素数。  
    302.         /// </summary>  
    303.         /// <param name="predicate">查询表达式</param>  
    304.         /// <returns></returns>  
    305.         public virtual async Task<int> CountAsync(Expression<Func<TEntity, bool>> predicate)  
    306.         {  
    307.             return await nContext.Set<TEntity>().CountAsync(predicate);  
    308.         }  
    309.     }  
    310. }  
  • 相关阅读:
    WinRAR的命令行模式用法介绍
    Linux find命令的用法实践
    Linux服务器磁盘扩展和oracle表空间文件迁移操作记录
    博客园开篇，自己开发的双色球小助手
    解决MySQL安装3306端口占用问题
    html书写行内元素时-tab和换行会在行内元素间引入间距
    FileReader生成图片dataurl的分析
    mysql启动流程
    npm--debug模块
    js之Symbol类型
  • 原文地址：https://www.cnblogs.com/sky-net/p/5593887.html
Copyright © 2011-2022 走看看