MVC仓储类Repository
接口：
using Common;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks; namespace Service
{
public interface IRepository<T> where T : class
{
#region 执行sql语句返回datatable
object SqlQueryForScalar(string sql, DbParameter[] parameters);
DataTable SqlQueryForDataTatable(string sql, DbParameter[] parameters);
#endregion #region 获取单条记录
/// <summary>
/// 通过lambda表达式获取一条记录p=>p.id==id
/// </summary>
T Get(Expression<Func<T, bool>> predicate); #endregion #region 单模型 CRUD 操作
/// <summary>
/// 增加一条记录
/// </summary>
/// <param name="entity">实体模型</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
bool Save(T entity, bool IsCommit = true);
/// <summary>
/// 增加一条记录（异步方式）
/// </summary>
/// <param name="entity">实体模型</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
Task<bool> SaveAsync(T entity, bool IsCommit = true); /// <summary>
/// 更新一条记录
/// </summary>
/// <param name="entity">实体模型</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
bool Update(T entity, bool IsCommit = true);
/// <summary>
/// 更新一条记录（异步方式）
/// </summary>
/// <param name="entity">实体模型</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
Task<bool> UpdateAsync(T entity, bool IsCommit = true); /// <summary>
/// 增加或更新一条记录
/// </summary>
/// <param name="entity">实体模型</param>
/// <param name="IsSave">是否增加</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
bool SaveOrUpdate(T entity, bool IsSave, bool IsCommit = true);
/// <summary>
/// 增加或更新一条记录（异步方式）
/// </summary>
/// <param name="entity">实体模型</param>
/// <param name="IsSave">是否增加</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
Task<bool> SaveOrUpdateAsync(T entity, bool IsSave, bool IsCommit = true); #endregion #region 多模型操作
/// <summary>
/// 增加多条记录，同一模型
/// </summary>
/// <param name="T1">实体模型集合</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
bool SaveList(List<T> T1, bool IsCommit = true);
/// <summary>
/// 增加多条记录，同一模型（异步方式）
/// </summary>
/// <param name="T1">实体模型集合</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
Task<bool> SaveListAsync(List<T> T1, bool IsCommit = true); /// <summary>
/// 增加多条记录，独立模型
/// </summary>
/// <param name="T1">实体模型集合</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
bool SaveList<T1>(List<T1> T, bool IsCommit = true) where T1 : class;
/// <summary>
/// 增加多条记录，独立模型（异步方式）
/// </summary>
/// <param name="T1">实体模型集合</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
Task<bool> SaveListAsync<T1>(List<T1> T, bool IsCommit = true) where T1 : class; /// <summary>
/// 更新多条记录，同一模型
/// </summary>
/// <param name="T1">实体模型集合</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
bool UpdateList(List<T> T1, bool IsCommit = true);
/// <summary>
/// 更新多条记录，同一模型（异步方式）
/// </summary>
/// <param name="T1">实体模型集合</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
Task<bool> UpdateListAsync(List<T> T1, bool IsCommit = true); /// <summary>
/// 更新多条记录，独立模型
/// </summary>
/// <param name="T1">实体模型集合</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
bool UpdateList<T1>(List<T1> T, bool IsCommit = true) where T1 : class;
/// <summary>
/// 更新多条记录，独立模型（异步方式）
/// </summary>
/// <param name="T1">实体模型集合</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
Task<bool> UpdateListAsync<T1>(List<T1> T, bool IsCommit = true) where T1 : class; /// <summary>
/// 删除多条记录，同一模型
/// </summary>
/// <param name="T1">实体模型集合</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
bool DeleteList(List<T> T1, bool IsCommit = true);
/// <summary>
/// 删除多条记录，同一模型（异步方式）
/// </summary>
/// <param name="T1">实体模型集合</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
Task<bool> DeleteListAsync(List<T> T1, bool IsCommit = true); /// <summary>
/// 删除多条记录，独立模型
/// </summary>
/// <param name="T1">实体模型集合</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
bool DeleteList<T1>(List<T1> T, bool IsCommit = true) where T1 : class;
/// <summary>
/// 删除多条记录，独立模型（异步方式）
/// </summary>
/// <param name="T1">实体模型集合</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
Task<bool> DeleteListAsync<T1>(List<T1> T, bool IsCommit = true) where T1 : class; /// <summary>
/// 通过Lamda表达式，删除一条或多条记录
/// </summary>
/// <param name="predicate"></param>
/// <param name="IsCommit"></param>
/// <returns></returns>
bool Delete(Expression<Func<T, bool>> predicate, bool IsCommit = true);
/// <summary>
/// 通过Lamda表达式，删除一条或多条记录（异步方式）
/// </summary>
/// <param name="predicate"></param>
/// <param name="IsCommit"></param>
/// <returns></returns>
Task<bool> DeleteAsync(Expression<Func<T, bool>> predicate, bool IsCommit = true); /// <summary>
/// 执行SQL删除
/// </summary>
/// <param name="sql">SQL语句</param>
/// <param name="para">Parameters参数</param>
int DeleteBySql(string sql, params DbParameter[] para);
/// <summary>
/// 执行SQL删除（异步方式）
/// </summary>
/// <param name="sql">SQL语句</param>
/// <param name="para">Parameters参数</param>
Task<int> DeleteBySqlAsync(string sql, params DbParameter[] para);
#endregion #region 存储过程操作
/// <summary>
/// 执行增删改存储过程
/// </summary>
object ExecuteProc(string procname, params DbParameter[] parameter);
/// <summary>
/// 执行查询的存储过程
/// </summary>
object ExecuteQueryProc(string procname, params DbParameter[] parameter);
#endregion #region 获取多条数据操作 /// <summary>
/// 返回IQueryable集合，延时加载数据
/// </summary>
/// <param name="predicate"></param>
/// <returns></returns>
IQueryable<T> LoadAll(Expression<Func<T, bool>> predicate);
/// <summary>
/// 返回IQueryable集合，延时加载数据（异步方式）
/// </summary>
/// <param name="predicate"></param>
/// <returns></returns>
Task<IQueryable<T>> LoadAllAsync(Expression<Func<T, bool>> predicate);
/// <summary>
/// 返回List<T>集合,不采用延时加载
/// </summary>
/// <param name="predicate"></param>
/// <returns></returns>
List<T> LoadListAll(Expression<Func<T, bool>> predicate);
/// <summary>
/// 返回List<T>集合,不采用延时加载（异步方式）
/// </summary>
/// <param name="predicate"></param>
/// <returns></returns>
Task<List<T>> LoadListAllAsync(Expression<Func<T, bool>> predicate);
/// <summary>
/// 获取DbQuery的列表
/// </summary>
/// <param name="predicate"></param>
/// <returns></returns>
DbQuery<T> LoadQueryAll(Expression<Func<T, bool>> predicate);
/// <summary>
/// 获取DbQuery的列表（异步方式）
/// </summary>
/// <param name="predicate"></param>
/// <returns></returns>
Task<DbQuery<T>> LoadQueryAllAsync(Expression<Func<T, bool>> predicate);
/// <summary>
/// 获取IEnumerable列表
/// </summary>
/// <param name="sql">SQL语句</param>
/// <param name="para">Parameters参数</param>
/// <returns></returns>
IEnumerable<T> LoadEnumerableAll(string sql, params DbParameter[] para);
/// <summary>
/// 获取IEnumerable列表（异步方式）
/// </summary>
/// <param name="sql">SQL语句</param>
/// <param name="para">Parameters参数</param>
/// <returns></returns>
Task<IEnumerable<T>> LoadEnumerableAllAsync(string sql, params DbParameter[] para);
/// <summary>
/// 获取数据动态集合
/// </summary>
/// <param name="sql">SQL语句</param>
/// <param name="para">Parameters参数</param>
/// <returns></returns>
IEnumerable LoadEnumerable(string sql, params DbParameter[] para);
/// <summary>
/// 获取数据动态集合（异步方式）
/// </summary>
/// <param name="sql">SQL语句</param>
/// <param name="para">Parameters参数</param>
/// <returns></returns>
Task<IEnumerable> LoadEnumerableAsync(string sql, params DbParameter[] para);
/// <summary>
/// 采用SQL进行数据的查询，返回IList集合
/// </summary>
/// <param name="sql">SQL语句</param>
/// <param name="para">Parameters参数</param>
/// <returns></returns>
List<T> SelectBySql(string sql, params DbParameter[] para);
/// <summary>
/// 采用SQL进行数据的查询，返回IList集合（异步方式）
/// </summary>
/// <param name="sql">SQL语句</param>
/// <param name="para">Parameters参数</param>
/// <returns></returns>
Task<List<T>> SelectBySqlAsync(string sql, params DbParameter[] para);
/// <summary>
/// 采用SQL进行数据的查询，指定泛型，返回IList集合
/// </summary>
/// <typeparam name="T1"></typeparam>
/// <param name="sql"></param>
/// <param name="para"></param>
/// <returns></returns>
List<T1> SelectBySql<T1>(string sql, params DbParameter[] para);
/// <summary>
/// 采用SQL进行数据的查询，指定泛型，返回IList集合
/// </summary>
/// <typeparam name="T1"></typeparam>
/// <param name="sql"></param>
/// <param name="para"></param>
/// <returns></returns>
Task<List<T1>> SelectBySqlAsync<T1>(string sql, params DbParameter[] para);
/// <summary>
/// 可指定返回结果、排序、查询条件的通用查询方法，返回实体对象集合
/// </summary>
/// <typeparam name="TEntity">实体对象</typeparam>
/// <typeparam name="TOrderBy">排序字段类型</typeparam>
/// <typeparam name="TResult">数据结果，与TEntity一致</typeparam>
/// <param name="where">过滤条件，需要用到类型转换的需要提前处理与数据表一致的</param>
/// <param name="orderby">排序字段</param>
/// <param name="selector">返回结果（必须是模型中存在的字段）</param>
/// <param name="IsAsc">排序方向，true为正序false为倒序</param>
/// <returns>实体集合</returns>
List<TResult> QueryEntity<TEntity, TOrderBy, TResult>(Expression<Func<TEntity, bool>> where, Expression<Func<TEntity, TOrderBy>> orderby, Expression<Func<TEntity, TResult>> selector, bool IsAsc)
where TEntity : class
where TResult : class;
/// <summary>
/// 可指定返回结果、排序、查询条件的通用查询方法，返回实体对象集合（异步方式）
/// </summary>
/// <typeparam name="TEntity">实体对象</typeparam>
/// <typeparam name="TOrderBy">排序字段类型</typeparam>
/// <typeparam name="TResult">数据结果，与TEntity一致</typeparam>
/// <param name="where">过滤条件，需要用到类型转换的需要提前处理与数据表一致的</param>
/// <param name="orderby">排序字段</param>
/// <param name="selector">返回结果（必须是模型中存在的字段）</param>
/// <param name="IsAsc">排序方向，true为正序false为倒序</param>
/// <returns>实体集合</returns>
Task<List<TResult>> QueryEntityAsync<TEntity, TOrderBy, TResult>(Expression<Func<TEntity, bool>> where, Expression<Func<TEntity, TOrderBy>> orderby, Expression<Func<TEntity, TResult>> selector, bool IsAsc)
where TEntity : class
where TResult : class; /// <summary>
/// 可指定返回结果、排序、查询条件的通用查询方法，返回Object对象集合
/// </summary>
/// <typeparam name="TEntity">实体对象</typeparam>
/// <typeparam name="TOrderBy">排序字段类型</typeparam>
/// <param name="where">过滤条件，需要用到类型转换的需要提前处理与数据表一致的</param>
/// <param name="orderby">排序字段</param>
/// <param name="selector">返回结果（必须是模型中存在的字段）</param>
/// <param name="IsAsc">排序方向，true为正序false为倒序</param>
/// <returns>自定义实体集合</returns>
List<object> QueryObject<TEntity, TOrderBy>(Expression<Func<TEntity, bool>> where, Expression<Func<TEntity, TOrderBy>> orderby, Func<IQueryable<TEntity>, List<object>> selector, bool IsAsc)
where TEntity : class;
/// <summary>
/// 可指定返回结果、排序、查询条件的通用查询方法，返回Object对象集合（异步方式）
/// </summary>
/// <typeparam name="TEntity">实体对象</typeparam>
/// <typeparam name="TOrderBy">排序字段类型</typeparam>
/// <param name="where">过滤条件，需要用到类型转换的需要提前处理与数据表一致的</param>
/// <param name="orderby">排序字段</param>
/// <param name="selector">返回结果（必须是模型中存在的字段）</param>
/// <param name="IsAsc">排序方向，true为正序false为倒序</param>
/// <returns>自定义实体集合</returns>
Task<List<object>> QueryObjectAsync<TEntity, TOrderBy>(Expression<Func<TEntity, bool>> where, Expression<Func<TEntity, TOrderBy>> orderby, Func<IQueryable<TEntity>, List<object>> selector, bool IsAsc)
where TEntity : class; /// <summary>
/// 可指定返回结果、排序、查询条件的通用查询方法，返回动态类对象集合
/// </summary>
/// <typeparam name="TEntity">实体对象</typeparam>
/// <typeparam name="TOrderBy">排序字段类型</typeparam>
/// <param name="where">过滤条件，需要用到类型转换的需要提前处理与数据表一致的</param>
/// <param name="orderby">排序字段</param>
/// <param name="selector">返回结果（必须是模型中存在的字段）</param>
/// <param name="IsAsc">排序方向，true为正序false为倒序</param>
/// <returns>动态类</returns>
dynamic QueryDynamic<TEntity, TOrderBy>(Expression<Func<TEntity, bool>> where, Expression<Func<TEntity, TOrderBy>> orderby, Func<IQueryable<TEntity>, List<object>> selector, bool IsAsc)
where TEntity : class;
/// <summary>
/// 可指定返回结果、排序、查询条件的通用查询方法，返回动态类对象集合（异步方式）
/// </summary>
/// <typeparam name="TEntity">实体对象</typeparam>
/// <typeparam name="TOrderBy">排序字段类型</typeparam>
/// <param name="where">过滤条件，需要用到类型转换的需要提前处理与数据表一致的</param>
/// <param name="orderby">排序字段</param>
/// <param name="selector">返回结果（必须是模型中存在的字段）</param>
/// <param name="IsAsc">排序方向，true为正序false为倒序</param>
/// <returns>动态类</returns>
Task<dynamic> QueryDynamicAsync<TEntity, TOrderBy>(Expression<Func<TEntity, bool>> where, Expression<Func<TEntity, TOrderBy>> orderby, Func<IQueryable<TEntity>, List<object>> selector, bool IsAsc)
where TEntity : class; #endregion #region 分页查询
Common.PageInfo<object> FindAll<TEntity>(int PageIndex, int PageSize, Expression<Func<TEntity, bool>> condition, String orderByExpression, bool IsDESC)
where TEntity : class;
/// <summary>
/// 通用EF分页，默认显示20条记录
/// </summary>
/// <typeparam name="TEntity">实体模型</typeparam>
/// <typeparam name="TOrderBy">排序类型</typeparam>
/// <param name="index">当前页</param>
/// <param name="pageSize">显示条数</param>
/// <param name="where">过滤条件</param>
/// <param name="orderby">排序字段</param>
/// <param name="selector">结果集合</param>
/// <param name="isAsc">排序方向true正序 false倒序</param>
/// <returns>自定义实体集合</returns>
PageInfo<object> Query<TEntity, TOrderBy>
(int index, int pageSize,
Expression<Func<TEntity, bool>> where,
Expression<Func<TEntity, TOrderBy>> orderby,
Func<IQueryable<TEntity>, List<object>> selector,
bool IsAsc)
where TEntity : class;
/// <summary>
/// 对IQueryable对象进行分页逻辑处理，过滤、查询项、排序对IQueryable操作
/// </summary>
/// <param name="t">Iqueryable</param>
/// <param name="index">当前页</param>
/// <param name="PageSize">每页显示多少条</param>
/// <returns>当前IQueryable to List的对象</returns>
Common.PageInfo<T> Query(IQueryable<T> query, int index, int PageSize);
/// <summary>
/// 普通SQL查询分页方法
/// </summary>
/// <param name="index">当前页</param>
/// <param name="pageSize">显示行数</param>
/// <param name="tableName">表名/视图</param>
/// <param name="field">获取项</param>
/// <param name="filter">过滤条件</param>
/// <param name="orderby">排序字段+排序方向</param>
/// <param name="group">分组字段</param>
/// <returns>结果集</returns>
Common.PageInfo Query(int index, int pageSize, string tableName, string field, string filter, string orderby, string group, params DbParameter[] para);
/// <summary>
/// 简单的Sql查询分页
/// </summary>
/// <param name="index"></param>
/// <param name="pageSize"></param>
/// <param name="sql"></param>
/// <returns></returns>
Common.PageInfo Query(int index, int pageSize, string sql, string orderby, params DbParameter[] para);
/// <summary>
/// 多表联合分页算法
/// </summary>
PageInfo Query(IQueryable query, int index, int pagesize);
#endregion #region ADO.NET增删改查方法
/// <summary>
/// 执行增删改方法,含事务处理
/// </summary>
object ExecuteSqlCommand(string sql, params DbParameter[] para);
/// <summary>
/// 执行多条SQL，增删改方法,含事务处理
/// </summary>
object ExecuteSqlCommand(Dictionary<string, object> sqllist);
/// <summary>
/// 执行查询方法,返回动态类，接收使用var，遍历时使用dynamic类型
/// </summary>
object ExecuteSqlQuery(string sql, params DbParameter[] para);
#endregion #region 更新操作
/// <summary>
/// 更新字段
/// </summary>
/// <param name="table">表名</param>
/// <param name="dic">被解析的字段</param>
/// <param name="where">条件</param>
/// <returns></returns>
//bool Modify(string table, Dictionary<string, object> dic, string where);
#endregion #region 验证是否存在 /// <summary>
/// 验证当前条件是否存在相同项
/// </summary>
bool IsExist(Expression<Func<T, bool>> predicate);
/// <summary>
/// 验证当前条件是否存在相同项（异步方式）
/// </summary>
Task<bool> IsExistAsync(Expression<Func<T, bool>> predicate);
/// <summary>
/// 根据SQL验证实体对象是否存在
/// </summary>
bool IsExist(string sql, params DbParameter[] para);
/// <summary>
/// 根据SQL验证实体对象是否存在（异步方式）
/// </summary>
Task<bool> IsExistAsync(string sql, params DbParameter[] para);
#endregion
}
}
实现：
using Domain;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Data.Entity;
using System.Data.Entity.Core.Objects;
using System.Data.Entity.Infrastructure;
using System.Data.SqlClient;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks; namespace Service
{
public abstract class RepositoryBase<T> : IRepository<T> where T : class
{ #region 执行sql语句返回datatable/object
/// <summary>
/// 执行查询并返回首行首列的值
/// </summary>
/// <param name="sql"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public object SqlQueryForScalar(string sql, DbParameter[] parameters)
{
string connStr = this.Context.Database.Connection.ConnectionString;
using (SqlConnection conn = new System.Data.SqlClient.SqlConnection(connStr))
{
if (conn.State != ConnectionState.Open)
{
conn.Open();
} SqlCommand cmd = new SqlCommand();
cmd.Connection = conn;
cmd.CommandText = sql;
cmd.CommandType = CommandType.Text; if (parameters != null && parameters.Length > )
{
foreach (var item in parameters)
{
cmd.Parameters.Add(item);
}
}
object obj = cmd.ExecuteScalar(); conn.Close();//连接需要关闭
conn.Dispose();
return obj;
}
}
/// <summary>
/// 执行查询并返回DataTable
/// </summary>
/// <param name="sql"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public DataTable SqlQueryForDataTatable(string sql, DbParameter[] parameters)
{
string connStr = this.Context.Database.Connection.ConnectionString;
using (SqlConnection conn = new System.Data.SqlClient.SqlConnection(connStr))
{
if (conn.State != ConnectionState.Open)
{
conn.Open();
}
SqlCommand cmd = new SqlCommand();
cmd.Connection = conn;
cmd.CommandText = sql;
cmd.CommandType = CommandType.Text; if (parameters != null && parameters.Length > )
{
foreach (var item in parameters)
{
cmd.Parameters.Add(item);
}
} SqlDataAdapter adapter = new SqlDataAdapter(cmd);
DataTable table = new DataTable();
adapter.Fill(table);
return table;
}
}
#endregion #region 获取单条记录
/// <summary>
/// 通过lambda表达式获取一条记录p=>p.id==id
/// </summary>
public virtual T Get(Expression<Func<T, bool>> predicate)
{
try
{
return dbSet.AsNoTracking().SingleOrDefault(predicate);
}
catch (Exception e)
{
throw e;
}
}
#endregion #region 单模型 CRUD 操作
/// <summary>
/// 增加一条记录
/// </summary>
/// <param name="entity">实体模型</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
public virtual bool Save(T entity, bool IsCommit = true)
{
try
{
int row = ;
var entry = this.Context.Entry<T>(entity);
entry.State = System.Data.Entity.EntityState.Added;
if (IsCommit)
{
row = Context.SaveChanges();
entry.State = System.Data.Entity.EntityState.Detached;
}
return row > ;
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// 增加一条记录（异步方式）
/// </summary>
/// <param name="entity">实体模型</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
public virtual Task<bool> SaveAsync(T entity, bool IsCommit = true)
{
try
{
int row = ;
var entry = this.Context.Entry<T>(entity);
entry.State = System.Data.Entity.EntityState.Added;
if (IsCommit)
{
row = Context.SaveChanges();
entry.State = System.Data.Entity.EntityState.Detached;
}
return Task.FromResult<bool>(row > );
}
catch (Exception e)
{
throw e;
}
} /// <summary>
/// 更新一条记录
/// </summary>
/// <param name="entity">实体模型</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
public virtual bool Update(T entity, bool IsCommit = true)
{
try
{
int rows = ;
var entry = this.Context.Entry(entity);
entry.State = System.Data.Entity.EntityState.Modified;
if (IsCommit)
{
rows = this.Context.SaveChanges();
entry.State = System.Data.Entity.EntityState.Detached;
}
return rows > ;
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// 更新一条记录（异步方式）
/// </summary>
/// <param name="entity">实体模型</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
public virtual Task<bool> UpdateAsync(T entity, bool IsCommit = true)
{
try
{
int rows = ;
var entry = this.Context.Entry(entity);
entry.State = System.Data.Entity.EntityState.Modified;
if (IsCommit)
{
rows = this.Context.SaveChanges();
entry.State = System.Data.Entity.EntityState.Detached;
}
return Task.FromResult<bool>(rows > );
}
catch (Exception e)
{
throw e;
}
} /// <summary>
/// 增加或更新一条记录
/// </summary>
/// <param name="entity">实体模型</param>
/// <param name="IsSave">是否增加</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
public virtual bool SaveOrUpdate(T entity, bool IsSave, bool IsCommit = true)
{
try
{
return IsSave ? Save(entity, IsCommit) : Update(entity, IsCommit);
}
catch (Exception e) { throw e; }
}
/// <summary>
/// 增加或更新一条记录（异步方式）
/// </summary>
/// <param name="entity">实体模型</param>
/// <param name="IsSave">是否增加</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
public virtual Task<bool> SaveOrUpdateAsync(T entity, bool IsSave, bool IsCommit = true)
{
try
{
return IsSave ? SaveAsync(entity, IsCommit) : UpdateAsync(entity, IsCommit);
}
catch (Exception e) { throw e; }
} /// <summary>
/// 更新字段
/// </summary>
/// <param name="table">表名</param>
/// <param name="dic">被解析的字段</param>
/// <param name="where">条件</param>
/// <returns></returns>
//public virtual bool Modify(string table, Dictionary<string, object> dic, string where)
//{
// try
// {
// string sql = "update "+table+" ";
// return this.Context.Database.ExecuteSqlCommand(sql, para);
// }
// catch (Exception e)
// {
// throw e;
// }
//}
#endregion #region 多模型操作 /// <summary>
/// 增加多模型数据，指定独立模型集合
/// </summary>
public virtual int SaveList<T1>(List<T1> t) where T1 : class
{
try
{
if (t == null || t.Count == ) return ;
this.Context.Set<T1>().Local.Clear();
foreach (var item in t)
{
this.Context.Set<T1>().Add(item);
}
return this.Context.SaveChanges();
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// 增加多模型数据，与当前模型一致
/// </summary>
public virtual int SaveList(List<T> t)
{
try
{
this.dbSet.Local.Clear();
foreach (var item in t)
{
this.dbSet.Add(item);
}
return this.Context.SaveChanges();
}
catch (Exception e)
{
throw e;
}
} /// <summary>
/// 增加多条记录，同一模型
/// </summary>
/// <param name="T1">实体模型集合</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
public virtual bool SaveList(List<T> T1, bool IsCommit = true)
{
try
{
if (T1 == null || T1.Count == ) return false;
this.Context.Set<T>().Local.Clear();
foreach (var item in T1)
{
this.Context.Set<T>().Add(item);
}
if (IsCommit)
{
return this.Context.SaveChanges() > ;
}
return false;
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// 增加多条记录，同一模型（异步方式）
/// </summary>
/// <param name="T1">实体模型集合</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
public virtual Task<bool> SaveListAsync(List<T> T1, bool IsCommit = true)
{
try
{
if (T1 == null || T1.Count == ) return Task.FromResult<bool>(false);
this.Context.Set<T>().Local.Clear();
foreach (var item in T1)
{
this.Context.Set<T>().Add(item);
}
if (IsCommit)
{
return Task.FromResult<bool>(this.Context.SaveChanges() > );
}
return Task.FromResult<bool>(false);
}
catch (Exception e)
{
throw e;
}
} /// <summary>
/// 增加多条记录，独立模型
/// </summary>
/// <param name="T1">实体模型集合</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
public virtual bool SaveList<T1>(List<T1> T, bool IsCommit = true) where T1 : class
{
try
{
if (T == null || T.Count == ) return false;
this.Context.Set<T1>().Local.Clear();
foreach (var item in T)
{
this.Context.Set<T1>().Add(item);
}
if (IsCommit)
{
return this.Context.SaveChanges() > ;
}
return false;
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// 增加多条记录，独立模型（异步方式）
/// </summary>
/// <param name="T1">实体模型集合</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
public virtual Task<bool> SaveListAsync<T1>(List<T1> T, bool IsCommit = true) where T1 : class
{
try
{
if (T == null || T.Count == ) return Task.FromResult<bool>(false);
this.Context.Set<T1>().Local.Clear();
foreach (var item in T)
{
this.Context.Set<T1>().Add(item);
}
if (IsCommit)
{
return Task.FromResult<bool>(this.Context.SaveChanges() > );
}
return Task.FromResult<bool>(false);
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// 更新多模型，指定独立模型集合
/// </summary>
public virtual int UpdateList<T1>(List<T1> t) where T1 : class
{
if (t.Count <= ) return ;
try
{
foreach (var item in t)
{
this.Context.Entry<T1>(item).State = System.Data.Entity.EntityState.Modified;
}
return this.Context.SaveChanges();
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// 更新多模型，与当前模型一致
/// </summary>
public virtual int UpdateList(List<T> t)
{
if (t.Count <= ) return ;
try
{
foreach (var item in t)
{
this.Context.Entry(item).State = System.Data.Entity.EntityState.Modified;
}
return this.Context.SaveChanges();
}
catch (Exception e) { throw e; }
}
/// <summary>
/// 更新多条记录，同一模型
/// </summary>
/// <param name="t">实体模型集合</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
public virtual bool UpdateList(List<T> t, bool IsCommit = true)
{
if (t.Count <= ) return false;
try
{
foreach (var item in t)
{
this.Context.Entry<T>(item).State = System.Data.Entity.EntityState.Modified;
}
if (IsCommit)
{
return this.Context.SaveChanges() > ;
}
return false;
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// 更新多条记录，同一模型（异步方式）
/// </summary>
/// <param name="t">实体模型集合</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
public virtual Task<bool> UpdateListAsync(List<T> t, bool IsCommit = true)
{
if (t.Count <= ) return Task.FromResult<bool>(false);
try
{
foreach (var item in t)
{
this.Context.Entry<T>(item).State = System.Data.Entity.EntityState.Modified;
}
if (IsCommit)
{
return Task.FromResult<bool>(this.Context.SaveChanges() > );
}
return Task.FromResult<bool>(false);
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// 更新多条记录，独立模型
/// </summary>
/// <param name="t">实体模型集合</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
public virtual bool UpdateList<T1>(List<T1> t, bool IsCommit = true) where T1 : class
{
if (t.Count <= ) return false;
try
{
foreach (var item in t)
{
this.Context.Entry<T1>(item).State = System.Data.Entity.EntityState.Modified;
}
if (IsCommit)
{
return this.Context.SaveChanges() > ;
}
return false;
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// 更新多条记录，独立模型（异步方式）
/// </summary>
/// <param name="t">实体模型集合</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
public virtual Task<bool> UpdateListAsync<T1>(List<T1> t, bool IsCommit = true) where T1 : class
{
if (t.Count <= ) return Task.FromResult<bool>(false);
try
{
foreach (var item in t)
{
this.Context.Entry<T1>(item).State = System.Data.Entity.EntityState.Modified;
}
if (IsCommit)
{
return Task.FromResult<bool>(this.Context.SaveChanges() > );
}
return Task.FromResult<bool>(false);
}
catch (Exception e)
{
throw e;
}
} /// <summary>
/// 批量删除数据，当前模型
/// </summary>
public virtual int DeleteList(List<T> t)
{
if (t == null || t.Count == ) return ;
foreach (var item in t)
{
this.dbSet.Remove(item);
}
return this.Context.SaveChanges();
}
/// <summary>
/// 批量删除数据，自定义模型
/// </summary>
public virtual int DeleteList<T1>(List<T1> t) where T1 : class
{
try
{
if (t == null || t.Count == ) return ;
foreach (var item in t)
{
this.Context.Set<T1>().Remove(item);
}
return this.Context.SaveChanges();
}
catch (Exception e) { throw e; }
} /// <summary>
/// 删除多条记录，同一模型
/// </summary>
/// <param name="T1">实体模型集合</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
public virtual bool DeleteList(List<T> T1, bool IsCommit = true)
{
if (T1 == null || T1.Count == ) return false;
foreach (var item in T1)
{
this.dbSet.Remove(item);
}
if (IsCommit)
{
return this.Context.SaveChanges() > ;
}
return false;
}
/// <summary>
/// 删除多条记录，同一模型（异步方式）
/// </summary>
/// <param name="T1">实体模型集合</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
public virtual Task<bool> DeleteListAsync(List<T> T1, bool IsCommit = true)
{
if (T1 == null || T1.Count == ) return Task.FromResult<bool>(false);
foreach (var item in T1)
{
this.dbSet.Remove(item);
}
if (IsCommit)
{
return Task.FromResult<bool>(this.Context.SaveChanges() > );
}
return Task.FromResult<bool>(false);
} /// <summary>
/// 删除多条记录，独立模型
/// </summary>
/// <param name="T1">实体模型集合</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
public virtual bool DeleteList<T1>(List<T1> t, bool IsCommit = true) where T1 : class
{
if (t == null || t.Count == ) return false;
foreach (var item in t)
{
this.Context.Set<T1>().Remove(item);
}
if (IsCommit)
{
return this.Context.SaveChanges() > ;
}
return false;
}
/// <summary>
/// 删除多条记录，独立模型（异步方式）
/// </summary>
/// <param name="T1">实体模型集合</param>
/// <param name="IsCommit">是否提交（默认提交）</param>
/// <returns></returns>
public virtual Task<bool> DeleteListAsync<T1>(List<T1> T, bool IsCommit = true) where T1 : class
{
if (T == null || T.Count == ) return Task.FromResult<bool>(false);
foreach (var item in T)
{
this.Context.Set<T1>().Remove(item);
}
if (IsCommit)
{
return Task.FromResult<bool>(this.Context.SaveChanges() > );
}
return Task.FromResult<bool>(false);
} /// <summary>
/// 通过Lamda表达式，删除一条或多条记录
/// </summary>
/// <param name="predicate"></param>
/// <param name="IsCommit"></param>
/// <returns></returns>
public virtual bool Delete(Expression<Func<T, bool>> predicate, bool IsCommit = true)
{
var data = this.dbSet.Where(predicate);
foreach (var item in data)
{
this.dbSet.Remove(item);
} if (IsCommit)
{
return this.Context.SaveChanges() > ;
}
return false;
}
/// <summary>
/// 通过Lamda表达式，删除一条或多条记录（异步方式）
/// </summary>
/// <param name="predicate"></param>
/// <param name="IsCommit"></param>
/// <returns></returns>
public virtual Task<bool> DeleteAsync(Expression<Func<T, bool>> predicate, bool IsCommit = true)
{
var data = this.dbSet.Where(predicate);
foreach (var item in data)
{
this.dbSet.Remove(item);
} if (IsCommit)
{
return Task.FromResult<bool>(this.Context.SaveChanges() > );
}
return Task.FromResult<bool>(false);
} #endregion #region 固定公用帮助，含事务 private DbContext context = new MyConfig().db;
/// <summary>
/// 数据上下文--->根据Domain实体模型名称进行更改
/// </summary>
public DbContext Context
{
get
{
context.Configuration.ValidateOnSaveEnabled = false;
return context;
}
}
/// <summary>
/// 数据上下文--->拓展属性
/// </summary>
public MyConfig Config
{
get
{
return new MyConfig();
}
}
/// <summary>
/// 公用泛型处理属性
/// 注:所有泛型操作的基础
/// </summary>
public DbSet<T> dbSet
{
get { return this.Context.Set<T>(); }
}
/// <summary>
/// 事务
/// </summary>
private DbContextTransaction _transaction = null;
/// <summary>
/// 开始事务
/// </summary>
public DbContextTransaction Transaction
{
get
{
if (this._transaction == null)
{
this._transaction = this.Context.Database.BeginTransaction();
}
return this._transaction;
}
set { this._transaction = value; }
}
/// <summary>
/// 事务状态
/// </summary>
public bool Committed { get; set; }
/// <summary>
/// 异步锁定
/// </summary>
private readonly object sync = new object();
/// <summary>
/// 提交事务
/// </summary>
public void Commit()
{
if (!Committed)
{
lock (sync)
{
if (this._transaction != null)
_transaction.Commit();
}
Committed = true;
}
}
/// <summary>
/// 回滚事务
/// </summary>
public void Rollback()
{
Committed = false;
if (this._transaction != null)
this._transaction.Rollback();
}
#endregion #region 增删改操作 /// <summary>
/// 添加一条模型记录，自动提交更改
/// </summary>
public virtual bool Save(T entity)
{
try
{
int row = ;
var entry = this.Context.Entry<T>(entity);
entry.State = System.Data.Entity.EntityState.Added;
row = Context.SaveChanges();
entry.State = System.Data.Entity.EntityState.Detached;
return row > ;
}
catch (Exception e)
{
throw e;
}
} /// <summary>
/// 更新一条模型记录，自动提交更改
/// </summary>
public virtual bool Update(T entity)
{
try
{
int rows = ;
var entry = this.Context.Entry(entity);
entry.State = System.Data.Entity.EntityState.Modified;
rows = this.Context.SaveChanges();
entry.State = System.Data.Entity.EntityState.Detached;
return rows > ;
}
catch (Exception e)
{
throw e;
}
} /// <summary>
/// 更新模型记录，如不存在进行添加操作
/// </summary>
public virtual bool SaveOrUpdate(T entity, bool isEdit)
{
try
{
return isEdit ? Update(entity) : Save(entity);
}
catch (Exception e) { throw e; }
} /// <summary>
/// 删除一条或多条模型记录，含事务
/// </summary>
public virtual int Delete(Expression<Func<T, bool>> predicate = null)
{
try
{
int rows = ;
IQueryable<T> entry = (predicate == null) ? this.dbSet.AsQueryable() : this.dbSet.Where(predicate);
List<T> list = entry.ToList();
if (list.Count > )
{
for (int i = ; i < list.Count; i++)
{
this.dbSet.Remove(list[i]);
}
rows = this.Context.SaveChanges();
}
return rows;
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// 使用原始SQL语句,含事务处理
/// </summary>
public virtual int DeleteBySql(string sql, params DbParameter[] para)
{
try
{
return this.Context.Database.ExecuteSqlCommand(sql, para);
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// 执行SQL删除（异步方式）
/// </summary>
/// <param name="sql">SQL语句</param>
/// <param name="para">Parameters参数</param>
public virtual Task<int> DeleteBySqlAsync(string sql, params DbParameter[] para)
{
return Task.FromResult<int>(DeleteBySql(sql, para));
}
#endregion #region 存储过程操作
/// <summary>
/// 执行返回影响行数的存储过程
/// </summary>
/// <param name="procname">过程名称</param>
/// <param name="parameter">参数对象</param>
/// <returns></returns>
public virtual object ExecuteProc(string procname, params DbParameter[] parameter)
{
try
{
return ExecuteSqlCommand(procname, parameter);
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// 执行返回结果集的存储过程
/// </summary>
/// <param name="procname">过程名称</param>
/// <param name="parameter">参数对象</param>
/// <returns></returns>
public virtual object ExecuteQueryProc(string procname, params DbParameter[] parameter)
{
try
{
return Context.Database.SqlFunctionForDynamic(procname, parameter);
}
catch (Exception e)
{
throw e;
}
}
#endregion #region 存在验证操作
/// <summary>
/// 验证当前条件是否存在相同项
/// </summary>
public virtual bool IsExist(Expression<Func<T, bool>> predicate)
{
var entry = this.dbSet.Where(predicate);
return (entry.Any());
} /// <summary>
/// 根据SQL验证实体对象是否存在
/// </summary>
public virtual bool IsExist(string sql, params DbParameter[] para)
{
IEnumerable result = this.Context.Database.SqlQuery(typeof(int), sql, para); if (result.GetEnumerator().Current == null || result.GetEnumerator().Current.ToString() == "")
return false;
return true;
} /// <summary>
/// 验证当前条件是否存在相同项（异步方式）
/// </summary>
public virtual Task<bool> IsExistAsync(Expression<Func<T, bool>> predicate)
{
return Task.FromResult<bool>(IsExist(predicate));
} /// <summary>
/// 根据SQL验证实体对象是否存在（异步方式）
/// </summary>
public virtual Task<bool> IsExistAsync(string sql, params DbParameter[] para)
{
return Task.FromResult<bool>(IsExist(sql, para));
}
#endregion #region 获取多条数据操作
/// <summary>
/// 返回IQueryable集合，延时加载数据
/// </summary>
public virtual IQueryable<T> LoadTop(Expression<Func<T, bool>> predicate, int TopNum)
{
try
{
if (predicate != null)
{
return this.dbSet.Where(predicate).Take(TopNum).AsNoTracking<T>();
}
return this.dbSet.AsQueryable<T>().AsNoTracking<T>();
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// 返回IQueryable集合，延时加载数据
/// </summary>
public virtual IQueryable<T> LoadAll(Expression<Func<T, bool>> predicate)
{
try
{
if (predicate != null)
{
return this.dbSet.Where(predicate).AsNoTracking<T>();
}
return this.dbSet.AsQueryable<T>().AsNoTracking<T>();
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// 返回IQueryable集合，延时加载数据（异步方式）
/// </summary>
/// <param name="predicate"></param>
/// <returns></returns>
public virtual Task<IQueryable<T>> LoadAllAsync(Expression<Func<T, bool>> predicate)
{
try
{
return Task.FromResult<IQueryable<T>>(LoadAll(predicate));
}
catch (Exception e)
{
throw e;
}
} /// <summary>
/// 返回DbQuery集合，延时加载数据
/// </summary>
public virtual DbQuery<T> LoadQueryAll(Expression<Func<T, bool>> predicate)
{
try
{
if (predicate != null)
{
return this.dbSet.Where(predicate) as DbQuery<T>;
}
return this.dbSet;
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// 获取DbQuery的列表（异步方式）
/// </summary>
/// <param name="predicate"></param>
/// <returns></returns>
public virtual Task<DbQuery<T>> LoadQueryAllAsync(Expression<Func<T, bool>> predicate)
{
try
{
return Task.FromResult<DbQuery<T>>(LoadQueryAll(predicate));
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// 返回List集合,不采用延时加载
/// </summary>
public virtual List<T> LoadListAll(Expression<Func<T, bool>> predicate)
{
try
{
if (predicate != null)
{
return this.dbSet.Where(predicate).AsNoTracking().ToList();
}
return this.dbSet.AsQueryable<T>().AsNoTracking().ToList();
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// 返回List<T>集合,不采用延时加载（异步方式）
/// </summary>
/// <param name="predicate"></param>
/// <returns></returns>
public virtual Task<List<T>> LoadListAllAsync(Expression<Func<T, bool>> predicate)
{
try
{
return Task.FromResult<List<T>>(LoadListAll(predicate));
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// 返回IEnumerable集合，采用原始T-Sql方式
/// </summary>
public virtual IEnumerable<T> LoadEnumerableAll(string sql, params DbParameter[] para)
{
try
{
return this.Context.Database.SqlQuery<T>(sql, para);
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// 获取IEnumerable列表（异步方式）
/// </summary>
/// <param name="sql">SQL语句</param>
/// <param name="para">Parameters参数</param>
/// <returns></returns>
public virtual Task<IEnumerable<T>> LoadEnumerableAllAsync(string sql, params DbParameter[] para)
{
try
{
return Task.FromResult<IEnumerable<T>>(LoadEnumerableAll(sql, para));
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// 返回IEnumerable动态集合，采用原始T-Sql方式
/// </summary>
public virtual System.Collections.IEnumerable LoadEnumerable(string sql, params DbParameter[] para)
{
try
{
return this.Context.Database.SqlQueryForDynamic(sql, para);
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// 获取数据动态集合（异步方式）
/// </summary>
/// <param name="sql">SQL语句</param>
/// <param name="para">Parameters参数</param>
/// <returns></returns>
public virtual Task<IEnumerable> LoadEnumerableAsync(string sql, params DbParameter[] para)
{
try
{
return Task.FromResult<IEnumerable>(LoadEnumerable(sql, para));
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// 返回IList集合，采用原始T-Sql方式
/// </summary>
public virtual List<T> SelectBySql(string sql, params DbParameter[] para)
{
try
{
return this.Context.Database.SqlQuery(typeof(T), sql, para).Cast<T>().ToList();
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// 采用SQL进行数据的查询，返回IList集合（异步方式）
/// </summary>
/// <param name="sql">SQL语句</param>
/// <param name="para">Parameters参数</param>
/// <returns></returns>
public virtual Task<List<T>> SelectBySqlAsync(string sql, params DbParameter[] para)
{
try
{
return Task.FromResult<List<T>>(SelectBySql<T>(sql, para));
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// 采用SQL进行数据的查询，指定泛型，返回IList集合
/// </summary>
/// <typeparam name="T1"></typeparam>
/// <param name="sql"></param>
/// <param name="para"></param>
/// <returns></returns>
public virtual Task<List<T1>> SelectBySqlAsync<T1>(string sql, params DbParameter[] para)
{
try
{
return Task.FromResult<List<T1>>(SelectBySql<T1>(sql, para));
}
catch (Exception e)
{
throw e;
}
} /// <summary>
/// 指定泛型，返回IList集合，采用原始T-Sql方式
/// </summary>
public virtual List<T1> SelectBySql<T1>(string sql, params DbParameter[] para)
{
try
{
return this.Context.Database.SqlQuery<T1>(sql, para).ToList();
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// 可指定返回结果、排序、查询条件的通用查询方法，返回实体对象
/// </summary>
/// <typeparam name="TEntity">实体对象</typeparam>
/// <typeparam name="TOrderBy">排序字段类型</typeparam>
/// <typeparam name="TResult">数据结果，与TEntity一致</typeparam>
/// <param name="where">过滤条件，需要用到类型转换的需要提前处理与数据表一致的</param>
/// <param name="orderby">排序字段</param>
/// <param name="selector">返回结果（必须是模型中存在的字段）</param>
/// <param name="IsAsc">排序方向，true为正序false为倒序</param>
/// <returns>实体集合</returns>
public virtual List<TResult> QueryEntity<TEntity, TOrderBy, TResult>
(Expression<Func<TEntity, bool>> where,
Expression<Func<TEntity, TOrderBy>> orderby,
Expression<Func<TEntity, TResult>> selector,
bool IsAsc)
where TEntity : class
where TResult : class
{
IQueryable<TEntity> query = this.Context.Set<TEntity>();
if (where != null)
{
query = query.Where(where);
} if (orderby != null)
{
query = IsAsc ? query.OrderBy(orderby) : query.OrderByDescending(orderby);
}
if (selector == null)
{
return query.Cast<TResult>().AsNoTracking().ToList();
}
return query.Select(selector).AsNoTracking().ToList();
} /// <summary>
/// 可指定返回结果、排序、查询条件的通用查询方法，返回实体对象集合（异步方式）
/// </summary>
/// <typeparam name="TEntity">实体对象</typeparam>
/// <typeparam name="TOrderBy">排序字段类型</typeparam>
/// <typeparam name="TResult">数据结果，与TEntity一致</typeparam>
/// <param name="where">过滤条件，需要用到类型转换的需要提前处理与数据表一致的</param>
/// <param name="orderby">排序字段</param>
/// <param name="selector">返回结果（必须是模型中存在的字段）</param>
/// <param name="IsAsc">排序方向，true为正序false为倒序</param>
/// <returns>实体集合</returns>
public virtual Task<List<TResult>> QueryEntityAsync<TEntity, TOrderBy, TResult>(Expression<Func<TEntity, bool>> where, Expression<Func<TEntity, TOrderBy>> orderby, Expression<Func<TEntity, TResult>> selector, bool IsAsc)
where TEntity : class
where TResult : class
{
return Task.FromResult<List<TResult>>(QueryEntity(where, orderby, selector, IsAsc));
} /// <summary>
/// 可指定返回结果、排序、查询条件的通用查询方法，返回Object对象
/// </summary>
/// <typeparam name="TEntity">实体对象</typeparam>
/// <typeparam name="TOrderBy">排序字段类型</typeparam>
/// <param name="where">过滤条件，需要用到类型转换的需要提前处理与数据表一致的</param>
/// <param name="orderby">排序字段</param>
/// <param name="selector">返回结果（必须是模型中存在的字段）</param>
/// <param name="IsAsc">排序方向，true为正序false为倒序</param>
/// <returns>自定义实体集合</returns>
public virtual List<object> QueryObject<TEntity, TOrderBy>
(Expression<Func<TEntity, bool>> where,
Expression<Func<TEntity, TOrderBy>> orderby,
Func<IQueryable<TEntity>,
List<object>> selector,
bool IsAsc)
where TEntity : class
{
IQueryable<TEntity> query = this.Context.Set<TEntity>();
if (where != null)
{
query = query.Where(where);
} if (orderby != null)
{
query = IsAsc ? query.OrderBy(orderby) : query.OrderByDescending(orderby);
}
if (selector == null)
{
return query.AsNoTracking().ToList<object>();
}
return selector(query);
} /// <summary>
/// 可指定返回结果、排序、查询条件的通用查询方法，返回Object对象集合（异步方式）
/// </summary>
/// <typeparam name="TEntity">实体对象</typeparam>
/// <typeparam name="TOrderBy">排序字段类型</typeparam>
/// <param name="where">过滤条件，需要用到类型转换的需要提前处理与数据表一致的</param>
/// <param name="orderby">排序字段</param>
/// <param name="selector">返回结果（必须是模型中存在的字段）</param>
/// <param name="IsAsc">排序方向，true为正序false为倒序</param>
/// <returns>自定义实体集合</returns>
public virtual Task<List<object>> QueryObjectAsync<TEntity, TOrderBy>(Expression<Func<TEntity, bool>> where, Expression<Func<TEntity, TOrderBy>> orderby, Func<IQueryable<TEntity>, List<object>> selector, bool IsAsc)
where TEntity : class
{
return Task.FromResult<List<object>>(QueryObject<TEntity, TOrderBy>(where, orderby, selector, IsAsc));
} /// <summary>
/// 可指定返回结果、排序、查询条件的通用查询方法，返回动态类对象
/// </summary>
/// <typeparam name="TEntity">实体对象</typeparam>
/// <typeparam name="TOrderBy">排序字段类型</typeparam>
/// <param name="where">过滤条件，需要用到类型转换的需要提前处理与数据表一致的</param>
/// <param name="orderby">排序字段</param>
/// <param name="selector">返回结果（必须是模型中存在的字段）</param>
/// <param name="IsAsc">排序方向，true为正序false为倒序</param>
/// <returns>动态类</returns>
public virtual dynamic QueryDynamic<TEntity, TOrderBy>
(Expression<Func<TEntity, bool>> where,
Expression<Func<TEntity, TOrderBy>> orderby,
Func<IQueryable<TEntity>,
List<object>> selector,
bool IsAsc)
where TEntity : class
{
List<object> list = QueryObject<TEntity, TOrderBy>
(where, orderby, selector, IsAsc);
return Common.JsonConverter.JsonClass(list);
}
/// <summary>
/// 可指定返回结果、排序、查询条件的通用查询方法，返回动态类对象集合（异步方式）
/// </summary>
/// <typeparam name="TEntity">实体对象</typeparam>
/// <typeparam name="TOrderBy">排序字段类型</typeparam>
/// <param name="where">过滤条件，需要用到类型转换的需要提前处理与数据表一致的</param>
/// <param name="orderby">排序字段</param>
/// <param name="selector">返回结果（必须是模型中存在的字段）</param>
/// <param name="IsAsc">排序方向，true为正序false为倒序</param>
/// <returns>动态类</returns>
public virtual Task<dynamic> QueryDynamicAsync<TEntity, TOrderBy>(Expression<Func<TEntity, bool>> where, Expression<Func<TEntity, TOrderBy>> orderby, Func<IQueryable<TEntity>, List<object>> selector, bool IsAsc)
where TEntity : class
{
return Task.FromResult<dynamic>(QueryDynamic<TEntity, TOrderBy>(where, orderby, selector, IsAsc));
}
#endregion #region 分页操作
/// <summary>
/// 待自定义分页函数，使用必须重写，指定数据模型
/// </summary>
public virtual IList<T1> PageByListSql<T1>(string sql, IList<DbParameter> parameters, Common.PageCollection page)
{
return null;
}
/// <summary>
/// 待自定义分页函数，使用必须重写，
/// </summary>
public virtual IList<T> PageByListSql(string sql, IList<DbParameter> parameters, Common.PageCollection page)
{
return null;
} /// <summary>
/// 对IQueryable对象进行分页逻辑处理，过滤、查询项、排序对IQueryable操作
/// </summary>
/// <param name="t">Iqueryable</param>
/// <param name="index">当前页</param>
/// <param name="PageSize">每页显示多少条</param>
/// <returns>当前IQueryable to List的对象</returns>
public virtual Common.PageInfo<T> Query(IQueryable<T> query, int index, int PageSize)
{
if (index < )
{
index = ;
}
if (PageSize <= )
{
PageSize = ;
}
int count = query.Count(); int maxpage = count / PageSize; if (count % PageSize > )
{
maxpage++;
}
if (index > maxpage)
{
index = maxpage;
}
if (count > )
query = query.Skip((index - ) * PageSize).Take(PageSize);
return new Common.PageInfo<T>(index, PageSize, count, query.ToList());
} public virtual Common.PageInfo<object> FindAll<TEntity>(int PageIndex, int PageSize, Expression<Func<TEntity, bool>> condition, String orderByExpression, bool IsDESC)
where TEntity : class
{
var property = typeof(TEntity).GetProperty(orderByExpression);
var parameter = Expression.Parameter(typeof(TEntity), "p");
var propertyAccess = Expression.MakeMemberAccess(parameter, property);
var orderByExp = Expression.Lambda(propertyAccess, parameter); IQueryable<TEntity> query = this.Context.Set<TEntity>();
if (condition != null)
{
query = query.Where(condition);
}
int count = query.Count(); string methodName = IsDESC ? "OrderByDescending" : "OrderBy";
MethodCallExpression resultExp = Expression.Call(typeof(Queryable), methodName, new Type[] { typeof(TEntity), property.PropertyType }, query.Expression, Expression.Quote(orderByExp));
query = query.Provider.CreateQuery<TEntity>(resultExp); return new Common.PageInfo<object>(PageIndex, PageSize, count, query.ToList<object>());
} /// <summary>
/// 通用EF分页，默认显示20条记录
/// </summary>
/// <typeparam name="TEntity">实体模型</typeparam>
/// <typeparam name="TOrderBy">排序类型</typeparam>
/// <param name="index">当前页</param>
/// <param name="pageSize">显示条数</param>
/// <param name="where">过滤条件</param>
/// <param name="orderby">排序字段</param>
/// <param name="selector">结果集合</param>
/// <param name="isAsc">排序方向true正序 false倒序</param>
/// <returns>自定义实体集合</returns>
public virtual Common.PageInfo<object> Query<TEntity, TOrderBy>
(int index, int pageSize,
Expression<Func<TEntity, bool>> where,
Expression<Func<TEntity, TOrderBy>> orderby,
Func<IQueryable<TEntity>, List<object>> selector,
bool isAsc)
where TEntity : class
{
if (index < )
{
index = ;
} if (pageSize <= )
{
pageSize = ;
} IQueryable<TEntity> query = this.Context.Set<TEntity>();
if (where != null)
{
query = query.Where(where);
}
int count = query.Count(); int maxpage = count / pageSize; if (count % pageSize > )
{
maxpage++;
}
if (index > maxpage)
{
index = maxpage;
} if (orderby != null)
{
query = isAsc ? query.OrderBy(orderby) : query.OrderByDescending(orderby);
}
if (count > )
query = query.Skip((index - ) * pageSize).Take(pageSize);
//返回结果为null，返回所有字段
if (selector == null)
return new Common.PageInfo<object>(index, pageSize, count, query.ToList<object>());
return new Common.PageInfo<object>(index, pageSize, count, selector(query).ToList());
}
/// <summary>
/// 普通SQL查询分页方法
/// </summary>
/// <param name="index">当前页</param>
/// <param name="pageSize">显示行数</param>
/// <param name="tableName">表名/视图</param>
/// <param name="field">获取项</param>
/// <param name="filter">过滤条件</param>
/// <param name="orderby">排序字段+排序方向</param>
/// <param name="group">分组字段</param>
/// <returns>结果集</returns>
public virtual Common.PageInfo Query(int index, int pageSize, string tableName, string field, string filter, string orderby, string group, params DbParameter[] para)
{
//执行分页算法
if (index <= )
index = ;
int start = (index - ) * pageSize;
if (start > )
start -= ;
else
start = ;
int end = index * pageSize; #region 查询逻辑
string logicSql = "SELECT";
//查询项
if (!string.IsNullOrEmpty(field))
{
logicSql += " " + field;
}
else
{
logicSql += " *";
}
logicSql += " FROM (" + tableName + " ) where";
//过滤条件
if (!string.IsNullOrEmpty(filter))
{
logicSql += " " + filter;
}
else
{
filter = " 1=1";
logicSql += " 1=1";
}
//分组
if (!string.IsNullOrEmpty(group))
{
logicSql += " group by " + group;
} #endregion //获取当前条件下数据总条数
int count = this.Context.Database.SqlQuery(typeof(int), "select count(*) from (" + tableName + ") where " + filter, para).Cast<int>().FirstOrDefault();
string sql = "SELECT T.* FROM ( SELECT B.* FROM ( SELECT A.*,ROW_NUMBER() OVER(ORDER BY getdate()) as RN" +
logicSql + ") A ) B WHERE B.RN<=" + end + ") T WHERE T.RN>" + start;
//排序
if (!string.IsNullOrEmpty(orderby))
{
sql += " order by " + orderby;
}
var list = ExecuteSqlQuery(sql, para) as IEnumerable;
if (list != null)
return new Common.PageInfo(index, pageSize, count, list.Cast<object>().ToList());
return new Common.PageInfo(index, pageSize, count, new { });
} /// <summary>
/// 最简单的SQL分页
/// </summary>
/// <param name="index">页码</param>
/// <param name="pageSize">显示行数</param>
/// <param name="sql">纯SQL语句</param>
/// <param name="orderby">排序字段与方向</param>
/// <returns></returns>
public virtual Common.PageInfo Query(int index, int pageSize, string sql, string orderby, params DbParameter[] para)
{
return this.Query(index, pageSize, sql, null, null, orderby, null, para);
}
/// <summary>
/// 多表联合分页算法
/// </summary>
public virtual Common.PageInfo Query(IQueryable query, int index, int PageSize)
{
var enumerable = (query as System.Collections.IEnumerable).Cast<object>();
if (index < )
{
index = ;
}
if (PageSize <= )
{
PageSize = ;
} int count = enumerable.Count(); int maxpage = count / PageSize; if (count % PageSize > )
{
maxpage++;
}
if (index > maxpage)
{
index = maxpage;
}
if (count > )
enumerable = enumerable.Skip((index - ) * PageSize).Take(PageSize);
return new Common.PageInfo(index, PageSize, count, enumerable.ToList());
}
#endregion #region ADO.NET增删改查方法
/// <summary>
/// 执行增删改方法,含事务处理
/// </summary>
public virtual object ExecuteSqlCommand(string sql, params DbParameter[] para)
{
try
{
return this.Context.Database.ExecuteSqlCommand(sql, para);
}
catch (Exception e)
{
throw e;
} }
/// <summary>
/// 执行多条SQL，增删改方法,含事务处理
/// </summary>
public virtual object ExecuteSqlCommand(Dictionary<string, object> sqllist)
{
try
{
int rows = ;
IEnumerator<KeyValuePair<string, object>> enumerator = sqllist.GetEnumerator();
using (Transaction)
{
while (enumerator.MoveNext())
{
rows += this.Context.Database.ExecuteSqlCommand(enumerator.Current.Key, enumerator.Current.Value);
}
Commit();
}
return rows;
}
catch (Exception e)
{
Rollback();
throw e;
} }
/// <summary>
/// 执行查询方法,返回动态类，接收使用var，遍历时使用dynamic类型
/// </summary>
public virtual object ExecuteSqlQuery(string sql, params DbParameter[] para)
{
try
{
return this.Context.Database.SqlQueryForDynamic(sql, para);
}
catch (Exception e)
{
throw e;
}
}
#endregion
}
}
context：
namespace Service
{
public interface IUnitOfWork
{
/// <summary>
/// 提交
/// </summary>
/// <returns></returns>
bool Commit();
}
}
using Domain;
using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using System.Text;
using System.Threading.Tasks; namespace Service
{
public class UnitOfWork : IUnitOfWork, IDisposable
{
#region 数据上下文 private DbContext context = new MyConfig().db;
/// <summary>
/// 数据上下文
/// </summary>
public DbContext _Context
{
get
{
context.Configuration.ValidateOnSaveEnabled = false;
return context;
}
} #endregion /// <summary>
/// 提交
/// </summary>
/// <returns></returns>
public bool Commit()
{
return _Context.SaveChanges() > ;
} public void Dispose()
{
if (_Context != null)
{
_Context.Dispose();
}
GC.SuppressFinalize(this);
}
}
}
扩展：
using System;
using System.Collections;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Data.Entity;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Text; namespace Service
{
/// <summary>
/// 查询动态类
/// add yuangang by 2016-05-10
/// </summary>
public static class DatabaseExtensions
{
/// <summary>
/// 自定义Connection对象
/// </summary>
private static IDbConnection DefaultConnection
{
get
{
return Domain.MyConfig.DefaultConnection;
}
}
/// <summary>
/// 自定义数据库连接字符串，与EF连接模式一致
/// </summary>
private static string DefaultConnectionString
{
get
{
return Domain.MyConfig.DefaultConnectionString;
}
}
/// <summary>
/// 动态查询主方法
/// </summary>
/// <returns></returns>
public static IEnumerable SqlQueryForDynamic(this Database db, string sql, params object[] parameters)
{
IDbConnection defaultConn = DefaultConnection; //ADO.NET数据库连接字符串
db.Connection.ConnectionString = DefaultConnectionString; return SqlQueryForDynamicOtherDB(db, sql, defaultConn, parameters);
}
private static IEnumerable SqlQueryForDynamicOtherDB(this Database db, string sql, IDbConnection conn, params object[] parameters)
{
conn.ConnectionString = db.Connection.ConnectionString; if (conn.State != ConnectionState.Open)
{
conn.Open();
} IDbCommand cmd = conn.CreateCommand();
cmd.CommandText = sql;
if (parameters != null)
{
foreach (var item in parameters)
{
cmd.Parameters.Add(item);
}
} using (IDataReader dataReader = cmd.ExecuteReader())
{ if (!dataReader.Read())
{
return null; //无结果返回Null
} #region 构建动态字段 TypeBuilder builder = DatabaseExtensions.CreateTypeBuilder(
"EF_DynamicModelAssembly",
"DynamicModule",
"DynamicType"); int fieldCount = dataReader.FieldCount;
for (int i = ; i < fieldCount; i++)
{
Type t = dataReader.GetFieldType(i);
switch (t.Name.ToLower())
{
case "decimal":
t = typeof(Decimal?);
break;
case "double":
t = typeof(Double?);
break;
case "datetime":
t = typeof(DateTime?);
break;
case "single":
t = typeof(float?);
break;
case "int16":
t = typeof(int?);
break;
case "int32":
t = typeof(int?);
break;
case "int64":
t = typeof(int?);
break;
default:
break;
}
DatabaseExtensions.CreateAutoImplementedProperty(
builder,
dataReader.GetName(i),
t);
} #endregion cmd.Parameters.Clear();
dataReader.Close();
dataReader.Dispose();
cmd.Dispose();
conn.Close();
conn.Dispose(); Type returnType = builder.CreateType(); if (parameters != null)
{
return db.SqlQuery(returnType, sql, parameters);
}
else
{
return db.SqlQuery(returnType, sql);
}
}
} private static TypeBuilder CreateTypeBuilder(string assemblyName, string moduleName, string typeName)
{
TypeBuilder typeBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(
new AssemblyName(assemblyName),
AssemblyBuilderAccess.Run).DefineDynamicModule(moduleName).DefineType(typeName,
TypeAttributes.Public);
typeBuilder.DefineDefaultConstructor(MethodAttributes.Public);
return typeBuilder;
} private static void CreateAutoImplementedProperty(TypeBuilder builder, string propertyName, Type propertyType)
{
const string PrivateFieldPrefix = "m_";
const string GetterPrefix = "get_";
const string SetterPrefix = "set_"; // Generate the field.
FieldBuilder fieldBuilder = builder.DefineField(
string.Concat(
PrivateFieldPrefix, propertyName),
propertyType,
FieldAttributes.Private); // Generate the property
PropertyBuilder propertyBuilder = builder.DefineProperty(
propertyName,
System.Reflection.PropertyAttributes.HasDefault,
propertyType, null); // Property getter and setter attributes.
MethodAttributes propertyMethodAttributes = MethodAttributes.Public
| MethodAttributes.SpecialName
| MethodAttributes.HideBySig; // Define the getter method.
MethodBuilder getterMethod = builder.DefineMethod(
string.Concat(
GetterPrefix, propertyName),
propertyMethodAttributes,
propertyType,
Type.EmptyTypes); // Emit the IL code.
// ldarg.0
// ldfld,_field
// ret
ILGenerator getterILCode = getterMethod.GetILGenerator();
getterILCode.Emit(OpCodes.Ldarg_0);
getterILCode.Emit(OpCodes.Ldfld, fieldBuilder);
getterILCode.Emit(OpCodes.Ret); // Define the setter method.
MethodBuilder setterMethod = builder.DefineMethod(
string.Concat(SetterPrefix, propertyName),
propertyMethodAttributes,
null,
new Type[] { propertyType }); // Emit the IL code.
// ldarg.0
// ldarg.1
// stfld,_field
// ret
ILGenerator setterILCode = setterMethod.GetILGenerator();
setterILCode.Emit(OpCodes.Ldarg_0);
setterILCode.Emit(OpCodes.Ldarg_1);
setterILCode.Emit(OpCodes.Stfld, fieldBuilder);
setterILCode.Emit(OpCodes.Ret); propertyBuilder.SetGetMethod(getterMethod);
propertyBuilder.SetSetMethod(setterMethod);
} public static dynamic SqlFunctionForDynamic(this Database db, string sql, params object[] parameters)
{
IDbConnection conn = DefaultConnection; //ADO.NET数据库连接字符串
conn.ConnectionString = DefaultConnectionString; if (conn.State != ConnectionState.Open)
{
conn.Open();
} IDbCommand cmd = conn.CreateCommand();
cmd.CommandText = sql;
cmd.CommandType = CommandType.StoredProcedure;
if (parameters != null)
{
foreach (var item in parameters)
{
cmd.Parameters.Add(item);
}
}
//1、DataReader查询数据
using (IDataReader dataReader = cmd.ExecuteReader())
{
if (!dataReader.Read())
{
return null;
}
//2、DataReader转换Json
string jsonstr = Common.JsonConverter.ToJson(dataReader);
dataReader.Close();
dataReader.Dispose();
cmd.Dispose();
conn.Close();
conn.Dispose();
//3、Json转换动态类
dynamic dyna = Common.JsonConverter.ConvertJson(jsonstr);
return dyna;
}
}
/// <summary>
/// 对可空类型进行判断转换(*要不然会报错)
/// </summary>
/// <param name="value">DataReader字段的值</param>
/// <param name="conversionType">该字段的类型</param>
/// <returns></returns>
private static object CheckType(object value, Type conversionType)
{
if (conversionType.IsGenericType && conversionType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
{
if (value == null)
return null;
System.ComponentModel.NullableConverter nullableConverter = new System.ComponentModel.NullableConverter(conversionType);
conversionType = nullableConverter.UnderlyingType;
}
return Convert.ChangeType(value, conversionType);
} /// <summary>
/// 判断指定对象是否是有效值
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
private static bool IsNullOrDBNull(object obj)
{
return (obj == null || (obj is DBNull)) ? true : false;
}
}
}
在RepositoryBase中又增加了两个备用方法：
接口：
#region 执行sql语句返回datatable
object SqlQueryForScalar(string sql, DbParameter[] parameters);
DataTable SqlQueryForDataTatable(string sql, DbParameter[] parameters);
#endregion
实现：
#region 执行sql语句返回datatable/object
/// <summary>
/// 执行查询并返回首行首列的值
/// </summary>
/// <param name="sql"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public object SqlQueryForScalar(string sql, DbParameter[] parameters)
{
string connStr = this.Context.Database.Connection.ConnectionString;
using (SqlConnection conn = new System.Data.SqlClient.SqlConnection(connStr))
{
if (conn.State != ConnectionState.Open)
{
conn.Open();
} SqlCommand cmd = new SqlCommand();
cmd.Connection = conn;
cmd.CommandText = sql;
cmd.CommandType = CommandType.Text; if (parameters != null && parameters.Length > )
{
foreach (var item in parameters)
{
cmd.Parameters.Add(item);
}
}
object obj = cmd.ExecuteScalar(); conn.Close();//连接需要关闭
conn.Dispose();
return obj;
}
}
/// <summary>
/// 执行查询并返回DataTable
/// </summary>
/// <param name="sql"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public DataTable SqlQueryForDataTatable(string sql, DbParameter[] parameters)
{
string connStr = this.Context.Database.Connection.ConnectionString;
using (SqlConnection conn = new System.Data.SqlClient.SqlConnection(connStr))
{
if (conn.State != ConnectionState.Open)
{
conn.Open();
}
SqlCommand cmd = new SqlCommand();
cmd.Connection = conn;
cmd.CommandText = sql;
cmd.CommandType = CommandType.Text; if (parameters != null && parameters.Length > )
{
foreach (var item in parameters)
{
cmd.Parameters.Add(item);
}
} SqlDataAdapter adapter = new SqlDataAdapter(cmd);
DataTable table = new DataTable();
adapter.Fill(table);
return table;
}
}
#endregion
MVC仓储类Repository的更多相关文章
- （译文）MVC通用仓储类
Generic Repository Pattern MVC Generic Repository Pattern MVC 原文链接:http://www.codeproject.com/Articl ...
- MVC通用仓储类
原文链接:http://www.codeproject.com/Articles/1095323/Generic-Repository-Pattern-MVC 良好的架构师任何项目的核心,开发人员一直 ...
- 在Apworks数据服务中使用基于Entity Framework Core的仓储（Repository）实现
<在ASP.NET Core中使用Apworks快速开发数据服务>一文中,我介绍了如何使用Apworks框架的数据服务来快速构建用于查询和管理数据模型的RESTful API,通过该文的介 ...
- C#数据仓储类
https://ninesky.codeplex.com/SourceControl/latest /*============================== 版本:v0.1 创建:2016.2 ...
- 用MVC5+EF6+WebApi 做一个考试功能(六) 仓储模式 打造EF通用仓储类
前言 年底工作比较忙,年度总结还没写,项目要上线,回老家过年各种准备.尤其是给长辈给侄子侄女准备礼物头都大了. 原来想年前先出一版能用的,我看有点悬了,尽量先把大体功能弄出来,扔掉一些,保证能考试,然 ...
- MVC单元测试,使用Repository模式、Ninject、Moq
本篇使用Repository设计MVC项目,使用Ninject作为DI容器,借助Moq进行单元测试. 模型和EF上下文 模型很简单: public class Foo { public int Id ...
- .Net Core之仓储（Repository）模式
我们经常在项目中使用仓储(Repository)模式,来实现解耦数据访问层与业务层.那在.net core使用EF core又是怎么做的呢? 现在我分享一下我的实现方案: 一.在领域层创建Reposi ...
- （转）MVC中的Repository模式
1.首先创建一个空的MVC3应用程序,命名为MyRepository.Web,解决方案命名为MyRepository. 2.添加一个类库项目,命名为MyRepository.DAL,添加一个文件夹命名 ...
- 扩展ASP.NET MVC HtmlHelper类
在这篇帖子中我会使用一个示例演示扩展ASP.NET MVC HtmlHelper类,让它们可以在你的MVC视图中工作.这个示例中我会提供一个简单的方案生成Html表格. HtmlHelper类 Htm ...
随机推荐
- windows CIFS sabma协议识别
今天在linux上搭建了CIFS协议,使用sabma4.7.0版本. 通过smbstatus可以查看smb软件的版本 通过/bin/smbstatus -d 0可以查看目前正连接的客户端. 问题来了: ...
- 洛谷 P2054 [AHOI2005]洗牌
题目描述 为了表彰小联为Samuel星球的探险所做出的贡献,小联被邀请参加Samuel星球近距离载人探险活动. 由于Samuel星球相当遥远,科学家们要在飞船中度过相当长的一段时间,小联提议用扑克牌打 ...
- 关于QT内部16进制、十进制、QByteArray，QString
QT里面的数据转化成十六进制比较麻烦,其他的int或者byte等型都有专门的函数,而十六进制没有特定的函数去转化,这我在具体的项目中已经解决(参考网上大神)->小项目程序 QT里面虽然有什么QS ...
- C# EF 基础操作
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.T ...
- starling 第一天
flashplayer_27_sa_debug: https://files.cnblogs.com/files/dt1991/flashplayer_27_sa_debug.rar flashpla ...
- 磁盘IO过高时的处理办法
针对系统中磁盘IO负载过高的指导性操作 主要命令:echo deadline > /sys/block/sda/queue/scheduler 注:以下的内容仅是提供参考,如果磁盘IO确实比较大 ...
- Linux逻辑卷的拉伸和缩小
相对于普通磁盘优势是逻辑卷可以在线动态的拉伸(不用先unmount操作),只要vg中有足够的空间即可 1:首先查看vg是否有足够的空间 [root@gechong mapper]# vgdisplay ...
- TCP/IP知识总结（TCP/IP协议族读书笔记二）
接下来,总结一下网络层的协议,IP,ARP,RARP,ICMP,IGMP.当我们在网络传输的过程中,把分组交付到主机或路由器需要两级地址:物理地址和逻辑地址.而且我们需要能够把物理地址映射成为相应的逻 ...
- How to Pronounce Ending T Clusters + Homophones — Baking!
How to Pronounce Ending T Clusters + Homophones — Baking! Share Tweet Share Tagged With: ARE Reducti ...
- 基于 tensorflow 的 mnist 数据集预测
1. tensorflow 基本使用方法 2. mnist 数据集简介与预处理 3. 聚类算法模型 4. 使用卷积神经网络进行特征生成 5. 训练网络模型生成结果 how to install ten ...