数据仓库，数据基础操作

/// <summary>
/// 此类作用：数据仓库，数据基础操作
/// </summary>
/// <typeparam name="TEntity">实体</typeparam>
/// <remarks>
/// zhangqc 2016.08.08 新建
/// </remarks>
public partial class Repository<TEntity> : IRepository<TEntity>, IDisposable
where TEntity : class
{
/// <summary>
/// 数据源上下文
/// </summary>
private readonly DbContext _ctx;

/// <summary>
/// 数据源上下文
/// </summary>
//[Obsolete("请小心使用")]
public DbContext DbContext
{
get
{
return _ctx;
}
}

/// <summary>
/// 命令执行超时时间，单位秒，默认为300秒。
/// </summary>
public int? CommandTimeout
{
get
{
return _ctx.Database.CommandTimeout;
}
set
{
_ctx.Database.CommandTimeout = value;
}
}

/// <summary>
/// 返回EntitySet
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public EntitySet EntitySet<T>()
{
var adapter = (IObjectContextAdapter)_ctx;
var objectContext = adapter.ObjectContext;
var objectSet = objectContext.CreateObjectSet<TEntity>();
return objectSet.EntitySet;
}

/// <summary>
/// 返回ObjectContext
/// </summary>
/// <returns></returns>
public ObjectContext ObjectContext()
{
var adapter = (IObjectContextAdapter)_ctx;
return adapter.ObjectContext; 
}


/// <summary>
/// 构造方法
/// </summary>
/// <param name="session"></param>
public Repository(DbContext session)
{
_ctx = session;
_ctx.Database.CommandTimeout = 300;
//_objCtx = ((IObjectContextAdapter)_ctx).ObjectContext;
}

/// <summary>
/// 获取指定记录集
/// </summary>
protected DbSet<T> DbSet<T>() where T : class
{
return _ctx.Set<T>();
}

#region IRepository<TEntity> Members

/// <summary>
/// 保存数据
/// </summary>
/// <returns>受影响的行数</returns>
public int Save()
{
try
{
return _ctx.SaveChanges();
}
catch (System.Data.Entity.Validation.DbEntityValidationException ex)
{
var msg = new List<string>();
foreach (var item in ex.EntityValidationErrors)
{
foreach (var err in item.ValidationErrors)
{
msg.Add(string.Format("{0} {1}", err.PropertyName, err.ErrorMessage));
}
}
throw new ApplicationException(string.Join("\n", msg));
}
}

/// <summary>
/// 添加当前实体
/// </summary>
/// <param name="t">实体</param>
/// <returns>添加后的实体</returns>
public TEntity Add(TEntity t)
{
return Add<TEntity>(t);
}

/// <summary>
/// 添加数据库中的实体
/// </summary>
/// <typeparam name="T">指定实体的类型</typeparam>
/// <param name="t">指定实体</param>
/// <returns>添加后的实体</returns>
public T Add<T>(T t)
where T : class
{
return DbSet<T>().Add(t);
}

/// <summary>
/// 批量添加或更新当前实体
/// </summary>
/// <param name="entity">当前实体，可多个一起传入</param>
public void AddOrUpdate(params TEntity[] entity)
{
DbSet<TEntity>().AddOrUpdate<TEntity>(entity);
}

/// <summary>
/// 批量添加或更新指定实体
/// </summary>
/// <typeparam name="T">指定实体类型</typeparam>
/// <param name="entity">指定实体，可多个一起传入</param>
public void AddOrUpdate<T>(params T[] entity) where T : class
{
DbSet<T>().AddOrUpdate<T>(entity);
}

/// <summary>
/// 更新当前实体
/// </summary>
/// <param name="entity">当前实体</param>
/// <returns>更新后的实体</returns>
public TEntity Update(TEntity entity)
{
return Update<TEntity>(entity);
}

/// <summary>
/// 更新指定实体
/// </summary>
/// <param name="entity">指定实体</param>
/// <returns>更新后的实体</returns>
public T Update<T>(T entity) where T : class
{
var entry = Attach(entity);
entry.State = EntityState.Modified;
return entity;
}

/// <summary>
/// 按需修改当前实体
/// </summary>
/// <param name="entity">实体对象</param>
/// <param name="modifiedPropertys">需要修改的字段</param>
/// <returns>修改状态后的实体</returns>
public TEntity Update(TEntity entity, List<string> modifiedPropertys)
{
return Update<TEntity>(entity, modifiedPropertys);
}

/// <summary>
/// 更新数据库中的实体
/// </summary>
/// <param name="entity">指定的实体</param>
/// <param name="modifiedPropertys">需要更新的字段名</param>
/// <returns>修改状态后的实体</returns>
public T Update<T>(T entity, List<string> modifiedPropertys) where T : class
{
var dbEntry = _ctx.Entry(entity);
dbEntry.State = EntityState.Unchanged;

if (null != modifiedPropertys)
{
modifiedPropertys.ForEach(p =>
{
dbEntry.Property(p).IsModified = true;
});
}
return entity;
}

/// <summary>
/// 删除当前实体
/// </summary>
/// <param name="entity">待删除的实体</param>
/// <returns>被删除的实体</returns>
public TEntity Delete(TEntity entity)
{
return Delete<TEntity>(entity);
}

/// <summary>
/// 删除当前实体列表
/// </summary>
/// <param name="list">待删除的实体列表</param>
public void Delete(IEnumerable<TEntity> list)
{
Delete<TEntity>(list);
}

/// <summary>
/// 删除当前实体列表
/// </summary>
/// <param name="list">待删除的实体</param>
public void Delete<T>(IEnumerable<T> list) where T : class
{
var l = list as IList<T> ?? list.ToList();
if (l.Any())
{
l.ForEach(p => Delete(p));
}
}
/// <summary>
/// 
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="list"></param>
public void Delete<T>(IQueryable<T> list) where T : class
{
if (list.Any())
{
list.ForEach(p => Delete(p));
}
}


/// <summary>
/// 从数据库中删除指定实体
/// </summary>
/// <typeparam name="T">待删除的实体类型</typeparam>
/// <param name="entity">待删除的实体</param>
/// <returns>被删除的实体</returns>
public T Delete<T>(T entity) where T : class
{
Attach(entity);
return DbSet<T>().Remove(entity);
}

/// <summary>
/// 删除数据库中指定实体
/// </summary>
/// <param name="predicate">条件</param>
public void Delete(Expression<Func<TEntity, bool>> predicate)
{
var dbSet = DbSet<TEntity>();
var q = dbSet.Where(predicate);
if (q.Any())
{
var l = q.ToList();
l.ForEach(p => dbSet.Remove(p));
}
}

/// <summary>
/// 删除数据库中指定实体
/// </summary>
/// <typeparam name="T">指定实体的类型</typeparam>
/// <param name="predicate">条件</param>
public void Delete<T>(Expression<Func<T, bool>> predicate) where T : class
{
var dbSet = DbSet<T>();
var q = dbSet.Where(predicate);
if (q.Any())
{
var l = q.ToList();
l.ForEach(p => dbSet.Remove(p));
}
}

/// <summary>
/// 删除当前实体，及关联实体
/// </summary>
/// <param name="entity">当前实体</param>
[Obsolete("测试中，暂不使用")]
public void DeleteRelatedEntries(TEntity entity)
{
throw new NotImplementedException();
}

/// <summary>
/// 按主键查询当前实体，多主键的参数需要按定义时的次序传入
/// </summary>
/// <param name="keyValues">主键值，可多个，按定义的顺序传入即可</param>
/// <returns>找到的实体</returns>
public TEntity Find(params object[] keyValues)
{
return Find<TEntity>(keyValues);
}

/// <summary>
/// 按主键查询指定实体，多主键的参数需要按定义时的次序传入
/// </summary>
/// <param name="keyValues">主键值，可多个，按定义的顺序传入即可</param>
/// <returns>找到的实体</returns>
public T Find<T>(params object[] keyValues) where T : class
{
return DbSet<T>().Find(keyValues);
}

/// <summary>
/// 根据条件查询当前实体
/// </summary>
/// <param name="predicate">按条件查询</param>
/// <returns>找到的实体</returns>
public TEntity Find(Expression<Func<TEntity, bool>> predicate)
{
return Find(DbSet<TEntity>(), predicate);
}

/// <summary>
/// 根据条件查询指定实体
/// </summary>
/// <typeparam name="T">指定的实体类型</typeparam>
/// <param name="predicate">按条件查询</param>
/// <returns>找到的实体</returns>
public T Find<T>(Expression<Func<T, bool>> predicate) where T : class
{
return Find(DbSet<T>(), predicate);
}

/// <summary>
/// 根据条件查询指定实体
/// </summary>
/// <typeparam name="T">指定实体类型</typeparam>
/// <param name="dbSet">指定记录集</param>
/// <param name="predicate">条件表达式</param>
/// <returns>符合条件的实体</returns>
public T Find<T>(DbQuery<T> dbSet, Expression<Func<T, bool>> predicate) where T : class
{
return dbSet.SingleOrDefault(predicate);
}

/// <summary>
/// 检查对象是否已存在
/// </summary>
/// <param name="predicate">查询条件</param>
/// <returns>True or False</returns>
public bool Any(Expression<Func<TEntity, bool>> predicate)
{
return Any(DbSet<TEntity>(), predicate);
}

/// <summary>
/// 检查对象是否已存在
/// </summary>
/// <param name="predicate">查询条件</param>
/// <returns>True or False</returns>
public bool Any<T>(Expression<Func<T, bool>> predicate) where T : class
{
return Any(DbSet<T>(), predicate);
}

/// <summary>
/// 检查对象是否已存在
/// </summary>
/// <typeparam name="T">指定实体类型</typeparam>
/// <param name="dbSet">指定记录集</param>
/// <param name="predicate">查询条件</param>
/// <returns>True or False</returns>
public bool Any<T>(DbQuery<T> dbSet, Expression<Func<T, bool>> predicate) where T : class
{
return dbSet.Any(predicate);
}

/// <summary>
/// 查当前记录集
/// </summary>
/// <returns>当前类型的所有记录数</returns>
public int Count()
{
return Count(DbSet<TEntity>());
}

/// <summary>
/// 查指定记录集
/// </summary>
/// <typeparam name="T">指定实体类型</typeparam>
/// <returns>所有记录数</returns>
public int Count<T>() where T : class
{
return Count(DbSet<T>());
}

/// <summary>
/// 查指定查询的记录集
/// </summary>
/// <typeparam name="T">指定实体类型</typeparam>
/// <param name="dbSet">指定记录集</param>
/// <returns>所有记录数</returns>
public int Count<T>(DbQuery<T> dbSet) where T : class
{
return dbSet.Count();
}

/// <summary>
/// 根据条件统计当前对象
/// </summary>
/// <param name="predicate"></param>
/// <returns></returns>
public int Count(Expression<Func<TEntity, bool>> predicate)
{
return Count(DbSet<TEntity>(), predicate);
}

/// <summary>
/// 根据条件统计数据库中对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="predicate"></param>
/// <returns></returns>
public int Count<T>(Expression<Func<T, bool>> predicate) where T : class
{
return Count(DbSet<T>(), predicate);
}

/// <summary>
/// 根据DbQuery条件统计数据库中对象
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <param name="dbSet">记录集</param>
/// <param name="predicate">条件</param>
/// <returns>符合条件的记录数</returns>
public int Count<T>(DbQuery<T> dbSet, Expression<Func<T, bool>> predicate) where T : class
{
return dbSet.Count(predicate);
}

/// <summary>
/// 查询实体，可对此进行后续操作。
/// </summary>
/// <returns>符合条件的结果集</returns>
public DbQuery<TEntity> DoQuery()
{
return DoQuery<TEntity>();
}

/// <summary>
/// 查询实体，可对此进行后续操作。
/// </summary>
/// <typeparam name="T">指定数据集类型</typeparam>
/// <returns>符合条件的结果集</returns>
public DbQuery<T> DoQuery<T>() where T : class
{
return DbSet<T>();
}

/// <summary>
/// 查询实体，可对此进行后续操作。
/// </summary>
/// <param name="predicate">条件表达式</param>
/// <returns>符合条件的结果集</returns>
public IQueryable<TEntity> DoQuery(Expression<Func<TEntity, bool>> predicate)
{
return DoQuery(DbSet<TEntity>(), predicate);
}


/// <summary>
/// 查询实体，可对此进行后续操作。
/// </summary>
/// <param name="predicate">条件表达式</param>
/// <returns>符合条件的结果集</returns>
public IEnumerable<TEntity> DoQueryFunc(Func<TEntity, bool> predicate)
{
return DoQueryFunc(DbSet<TEntity>(), predicate);
}
/// <summary>
/// 查询实体，可对此进行后续操作。
/// </summary>
/// <typeparam name="T">指定数据集类型</typeparam>
/// <param name="predicate">条件表达式</param>
/// <returns>符合条件的结果集</returns>
public IQueryable<T> DoQuery<T>(Expression<Func<T, bool>> predicate) where T : class
{
return DoQuery(DbSet<T>(), predicate);
}

/// <summary>
/// 查询实体，可对此进行后续操作。
/// </summary>
/// <typeparam name="T">指定数据集类型</typeparam>
/// <param name="dbSet">数据集</param>
/// <param name="predicate">条件表达式</param>
/// <returns>符合条件的结果集</returns>
public IQueryable<T> DoQuery<T>(DbQuery<T> dbSet, Expression<Func<T, bool>> predicate) where T : class
{
return dbSet.Where(predicate);
}

 

/// <summary>
/// 查询实体，可对此进行后续操作。
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="dbSet"></param>
/// <param name="predicate"></param>
/// <returns></returns>
public IEnumerable<T> DoQueryFunc<T>(DbQuery<T> dbSet, Func<T, bool> predicate) where T : class
{
return dbSet.Where(predicate);
}

/// <summary>
/// 查询实体，可对此进行后续操作。
/// </summary>
/// <param name="predicate">条件表达式</param>
/// <param name="sort">排序表达式</param>
/// <param name="skip">Skip索引</param>
/// <param name="take">当前取的数量</param>
/// <returns>符合条件的结果集</returns>
public IQueryable<TEntity> DoQuery(Expression<Func<TEntity, bool>> predicate, Expression<Func<TEntity, object>> sort, int skip, int take)
{
return DoQuery(DbSet<TEntity>(), predicate, sort, skip, take);
}

/// <summary>
/// 查询实体，可对此进行后续操作。
/// </summary>
/// <typeparam name="T">指定数据集类型</typeparam>
/// <param name="dbSet">数据集</param>
/// <param name="predicate">条件表达式</param>
/// <param name="sort">排序表达式</param>
/// <param name="skip">Skip索引</param>
/// <param name="take">当前取的数量</param>
/// <returns>符合条件的结果集</returns>
public IQueryable<T> DoQuery<T>(DbQuery<T> dbSet, Expression<Func<T, bool>> predicate, Expression<Func<T, object>> sort, int skip, int take) where T : class
{
return dbSet.Skip(skip).Take(take).OrderBy(sort);
}

/// <summary>
/// 执行SQL
/// </summary>
/// <param name="sql">SQL</param>
/// <param name="parameters">参数</param>
/// <returns>受影响的语句数量</returns>
public int ExecuteSqlCommand(string sql, params object[] parameters)
{
return _ctx.Database.ExecuteSqlCommand(sql, parameters);
}

#endregion

#region IDisposable Members

/// <summary>
/// 释放资源
/// </summary>
public void Dispose()
{
if (null != _ctx)
{
_ctx.Dispose();
}
}

#endregion

#region 非公有方法

/// <summary>
/// 附加指定实体
/// </summary>
/// <typeparam name="T">指定的实体类型</typeparam>
/// <param name="entity">实体数据</param>
/// <returns></returns>
protected DbEntityEntry<T> Attach<T>(T entity) where T : class
{
var entry = _ctx.Entry(entity);
if (entry.State == EntityState.Detached)
{
DbSet<T>().Attach(entity);
}
return entry;
}

/// <summary>
/// 获取所有主键
/// </summary>
/// <param name="entity">实体</param>
/// <returns>主键名列表</returns>
protected IEnumerable<string> GetKeyPropertyNames(object entity)
{
var objContext = ((IObjectContextAdapter)_ctx).ObjectContext;
return objContext.ObjectStateManager
.GetObjectStateEntry(entity)
.EntityKey
.EntityKeyValues
.Select(k => k.Key);
}

#endregion

}