直奔主题了，不那么啰嗦。
一下分三个步骤说明，分别为 dbContext,repository,uow三点
在说之前，先说下O# 因为最近发现还有人在问，其实很好理解，简要说下理解步骤（O#的整体框架和上面的截图类似->_->我就是仿照的o#搭建的好不好）
如果对respository+uow熟练的人 ，一下就能看懂
看图一，图中的Core.Data.Entity
说实话，我也偷懒了，以下是 IRepository和IUnitofWork的定义
IRepository:
/// <summary>
/// 实现仓储模型的数据标准操作
/// </summary>
public interface IRepository<TEntity> : IDependency
{
#region 属性
/// <summary>
/// 获取 当前单元操作对象
/// </summary>
IUnitOfWork UnitOfWork { get; }
/// <summary>
/// 获取当前实体查询数据集，数据将使用不跟踪变化的方式来查询
/// </summary>
IQueryable<TEntity> Entites { get; } #endregion #region 方法
/// <summary>
/// 插入实体
/// </summary>
/// <param name="entity">实体对象</param>
/// <returns>操作影响的行数</returns>
int Insert(TEntity entity, bool save = true); /// <summary>
/// 批量插入实体
/// </summary>
/// <param name="entities">实体对象集合</param>
/// <returns>操作影响的行数</returns>
int Insert(IEnumerable<TEntity> entities, bool save = true); /// <summary>
/// 删除实体
/// </summary>
/// <param name="entity">实体对象</param>
/// <returns>操作影响的行数</returns>
int Delete(TEntity entity, bool save = true); /// <summary>
/// 删除指定编号的实体
/// </summary>
/// <param name="key">实体主键</param>
/// <returns>操作影响的行数</returns>
int Delete(object key, bool save = true); /// <summary>
/// 删除所有符合特定条件的实体
/// </summary>
/// <param name="predicate">查询条件谓语表达式</param>
/// <returns>操作影响的行数</returns>
int Delete(Expression<Func<TEntity, bool>> predicate, bool save = true); /// <summary>
/// 批量删除实体
/// </summary>
/// <param name="entities">实体对象集合</param>
/// <returns>操作影响的行数</returns>
int Delete(IEnumerable<TEntity> entities, bool save = true); /// <summary>
/// 更新指定主键的对象
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
int Update(object key, bool save = true); /// <summary>
/// 更新实体对象
/// </summary>
/// <param name="entity">更新后的实体对象</param>
/// <returns>操作影响的行数</returns>
int Update(TEntity entity, bool save = true);
/// <summary>
/// 批量更新数据
/// </summary>
/// <param name="entites">对象集合</param>
/// <returns></returns>
int Update(IEnumerable<TEntity> entites, bool save = true);
///// <summary>
///// 检查实体是否存在
///// </summary>
///// <param name="predicate">查询条件谓语表达式</param>
///// <param name="id">编辑的实体标识</param>
///// <returns>是否存在</returns>
//bool CheckExists(Expression<Func<TEntity, bool>> predicate, object id); /// <summary>
/// 查找指定主键的实体
/// </summary>
/// <param name="key">实体主键</param>
/// <returns>符合主键的实体，不存在时返回null</returns>
TEntity GetByKey(object key); /// <summary>
/// 查询指定条件的实体
/// </summary>
/// <param name="predicate">查询表达式</param>
/// <returns>符合条件的实体集合</returns>
IEnumerable<TEntity> GetByPredicate(Expression<Func<TEntity, bool>> predicate); /// <summary>
/// 获取贪婪加载导航属性的查询数据集
/// </summary>
/// <param name="path">属性表达式，表示要贪婪加载的导航属性</param>
/// <returns>查询数据集</returns>
IQueryable<TEntity> GetInclude<TProperty>(Expression<Func<TEntity, TProperty>> path); /// <summary>
/// 获取贪婪加载多个导航属性的查询数据集
/// </summary>
/// <param name="paths">要贪婪加载的导航属性名称数组</param>
/// <returns>查询数据集</returns>
IQueryable<TEntity> GetIncludes(params string[] paths); /// <summary>
/// 创建一个原始 SQL 查询，该查询将返回此集中的实体。
/// 默认情况下，上下文会跟踪返回的实体；可通过对返回的 DbRawSqlQuery 调用 AsNoTracking 来更改此设置。 请注意返回实体的类型始终是此集的类型，而不会是派生的类型。 如果查询的一个或多个表可能包含其他实体类型的数据，则必须编写适当的 SQL 查询以确保只返回适当类型的实体。 与接受 SQL 的任何 API 一样，对任何用户输入进行参数化以便避免 SQL 注入攻击是十分重要的。 您可以在 SQL 查询字符串中包含参数占位符，然后将参数值作为附加参数提供。 您提供的任何参数值都将自动转换为 DbParameter。 context.Set(typeof(Blog)).SqlQuery("SELECT * FROM dbo.Posts WHERE Author = @p0", userSuppliedAuthor); 或者，您还可以构造一个 DbParameter 并将它提供给 SqlQuery。 这允许您在 SQL 查询字符串中使用命名参数。 context.Set(typeof(Blog)).SqlQuery("SELECT * FROM dbo.Posts WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor));
/// </summary>
/// <param name="trackEnabled">是否跟踪返回实体</param>
/// <param name="sql">SQL 查询字符串。</param>
/// <param name="parameters">要应用于 SQL 查询字符串的参数。 如果使用输出参数，则它们的值在完全读取结果之前不可用。 这是由于 DbDataReader 的基础行为而导致的，有关详细信息，请参见 http://go.microsoft.com/fwlink/?LinkID=398589。</param>
/// <returns></returns>
IEnumerable<TEntity> SqlQuery(string sql, bool trackEnabled = true, params object[] parameters); /// <summary>
/// 分页数据查询
/// </summary>
/// <param name="pageCondition">分页和排序条件</param>
/// <param name="predicate">数据过滤条件 表达式</param>
/// <returns>分页后的数据集合</returns>
IQueryable<TEntity> Get(PageCondition pageCondition, Expression<Func<TEntity, bool>> predicate, out int totalRow); #endregion }
IUnitOfWork：
/// <summary>
///
/// </summary>
public interface IUnitOfWork: IDependency, IDisposable
{ #region 方法
/// <summary>
/// 命令提交
/// </summary>
/// <returns>提交操作结果</returns>
int SaveChanges(bool save); DbContext DbContext { get; }
#endregion }
此处之所以这么定义（只有两个对象），看上一篇关于 repository和uow的关系
对应的repository和uow的实现
repository:
/// <summary>
/// 仓储
/// </summary>
public class Repository<TEntity> : IRepository<TEntity> where TEntity : class
{
#region Fields
private readonly IUnitOfWork _unitOfWork;
private readonly DbSet<TEntity> _dbSet;
#endregion #region ctor
/// <summary>
/// 初始化一个<see cref="Repository{TEntity}"/>类型的新实例
/// </summary>
public Repository(IUnitOfWork unitOfWork)
{
this._unitOfWork = unitOfWork;
this._dbSet = _unitOfWork.DbContext.Set<TEntity>();
}
#endregion #region 属性
/// <summary>
/// 获取 当前实体类型的查询数据集，数据将使用不跟踪变化的方式来查询
/// </summary>
public IQueryable<TEntity> Entites { get { return _dbSet.AsNoTracking(); } }
/// <summary>
/// 获取 当前单元操作对象
/// </summary>
public IUnitOfWork UnitOfWork { get { return _unitOfWork; } } #endregion #region 方法 ///// <summary>
///// 判断指定表达式条件 的对象是否存在
///// </summary>
///// <param name="predicate"></param>
///// <param name="id"></param>
///// <returns></returns>
//public bool CheckExists(Expression<Func<TEntity, bool>> predicate, object id)
//{
// var entity = _dbSet.Where(predicate).Select(m => )
//}
/// <summary>
/// 删除所有符合特定条件的实体
/// </summary>
/// <param name="predicate">查询条件谓语表达式</param>
/// <returns>操作影响的行数</returns>
public int Delete(Expression<Func<TEntity, bool>> predicate, bool save = true)
{
var entities = _dbSet.Where(predicate).AsEnumerable();
if (null != entities && entities.Count() > )
{
_dbSet.RemoveRange(entities);
}
return _unitOfWork.SaveChanges(save);
}
/// <summary>
/// 批量删除实体
/// </summary>
/// <param name="entities">实体对象集合</param>
/// <returns>操作影响的行数</returns>
public int Delete(IEnumerable<TEntity> entities, bool save = true)
{
if (null != entities && entities.Count() > )
{
_dbSet.RemoveRange(entities);
}
return _unitOfWork.SaveChanges(save);
} public int Delete(object key, bool save = true)
{
var entity = _dbSet.Find(key);
_dbSet.Remove(entity);
return _unitOfWork.SaveChanges(save);
} public int Delete(TEntity entity, bool save = true)
{
_dbSet.Remove(entity);
return _unitOfWork.SaveChanges(save);
} public TEntity GetByKey(object key)
{
return _dbSet.Find(key);
} public IEnumerable<TEntity> GetByPredicate(Expression<Func<TEntity, bool>> predicate)
{
return _dbSet.Where(predicate).AsEnumerable();
} public IQueryable<TEntity> GetInclude<TProperty>(Expression<Func<TEntity, TProperty>> path)
{
return _dbSet.Include(path);
} public IQueryable<TEntity> GetIncludes(params string[] paths)
{
IQueryable<TEntity> sources = null;
foreach (var path in paths)
{
sources = _dbSet.Include(path);
}
return sources;
} public int Insert(IEnumerable<TEntity> entities, bool save = true)
{
_dbSet.AddRange(entities);
return _unitOfWork.SaveChanges(save);
} public int Insert(TEntity entity, bool save = true)
{
_dbSet.Add(entity);
return _unitOfWork.SaveChanges(save);
} public IEnumerable<TEntity> SqlQuery(string sql, bool trackEnabled = true, params object[] parameters)
{
return trackEnabled
? _dbSet.SqlQuery(sql, parameters)
: _dbSet.SqlQuery(sql, parameters).AsNoTracking();
} public int Update(object key, bool save = true)
{
var entity = _dbSet.Find(key);
return Update(entity, save);
} public int Update(TEntity entity, bool save = true)
{
DbContext context = ((DbContext)_unitOfWork); DbSet<TEntity> dbSet = context.Set<TEntity>();
try
{
DbEntityEntry<TEntity> entry = context.Entry(entity);
if (entry.State == EntityState.Detached)
{
dbSet.Attach(entity);
entry.State = EntityState.Modified;
}
}
catch (InvalidOperationException ex)
{
throw new Exception(ex.Message);
}
return _unitOfWork.SaveChanges(save);
} public int Update(IEnumerable<TEntity> entites, bool save = true)
{
DbContext context = ((DbContext)_unitOfWork); DbSet<TEntity> dbSet = context.Set<TEntity>(); foreach (var entity in entites)
{
try
{
DbEntityEntry<TEntity> entry = context.Entry(entity);
if (entry.State == EntityState.Detached)
{
dbSet.Attach(entity);
entry.State = EntityState.Modified;
}
}
catch (InvalidOperationException ex)
{
throw new Exception(ex.Message);
}
} return _unitOfWork.SaveChanges(save);
} public IQueryable<TEntity> Get(PageCondition pageCondition, Expression<Func<TEntity, bool>> predicate, out int totalRow)
{
int totalCount = ;
IQueryable<TEntity> source = _dbSet.Where(predicate);
if (pageCondition.SortConditions == null || pageCondition.SortConditions.Length == )
{
source = source.OrderBy("Id");
}
else
{
int count = ;
IOrderedQueryable<TEntity> orderSource = null;
foreach (SortCondition sortCondition in pageCondition.SortConditions)
{
orderSource = count ==
? CollectionPropertySorter<TEntity>.OrderBy(source, sortCondition.SortField, sortCondition.ListSortDirection)
: CollectionPropertySorter<TEntity>.ThenBy(orderSource, sortCondition.SortField, sortCondition.ListSortDirection);
count++;
}
source = orderSource;
totalCount = source.Count();
}
int pageIndex = pageCondition.PageIndex, pageSize = pageCondition.PageSize;
source = source != null
? source.Skip((pageIndex - ) * pageSize).Take(pageSize)
: Enumerable.Empty<TEntity>().AsQueryable();
//IQueryable<TResult> query = source.Select(selector);
//return GetKey(query.Expression);
totalRow = totalCount;
return source;
} #endregion }
uow:
/// <summary>
/// 工作单元实现
/// </summary>
public class UnitOfWork : IUnitOfWork
{
private bool _disposed;
private DbContext _dbContext; public UnitOfWork()
{
this._dbContext = DbContext;
} /// <summary>
/// 数据提交操作
/// </summary>
/// <returns></returns>
public int SaveChanges(bool save)
{
if (save)
{
try
{
try
{
return _dbContext.SaveChanges();
}
catch (DbEntityValidationException dbex)
{ throw;
}
}
catch (Exception ex)
{ throw;
}
}
return ;
} public DbContext DbContext
{
get
{
//CallContext：是线程内部唯一的独用的数据槽（一块内存空间）
//传递DbContext进去获取实例的信息，在这里进行强制转换。
DbContext dbContext = CallContext.GetData("DbContext") as DbContext;
if (dbContext == null) //线程在数据槽里面没有此上下文
{
dbContext = new InnovatorContext(); //如果不存在上下文的话，创建一个EF上下文
//我们在创建一个，放到数据槽中去
CallContext.SetData("DbContext", dbContext);
}
return dbContext;
}
} public virtual void Dispose(bool disposing)
{
if (!this._disposed)
if (disposing)
this._dbContext.Dispose(); this._disposed = true;
} public void Dispose()
{
Dispose(true);
}
}
脚本中涉及到的 SortDirection源自O#的干货中的实现，具体参见 o#
至此，该内容已完毕，以上实现院子处处有，再说闲的多余了。