回到目录
之前写过关于实现一个完整的ＥＦ架构的文章，文章的阅读量也是满大的，自己很欣慰，但是，那篇文章是我２０１１年写的，所以，技术有些不成熟，所以今天把我的２０１４年写的EF底层架构公开一下，这个架构比２０１１年的有了很大程度的提高，主要在接口规范，查询规范上，并引入了排序功能，两步对完善了ＥＦ对数据的批量操作，可以说，这次的架构是很有看点的。
一 一个基础操作接口
/// <summary>
/// 基础的数据操作规范
/// 与ＯＲＭ架构无关
/// </summary>
/// <typeparam name="TEntity"></typeparam>
public interface IRepository<TEntity>
where TEntity : class
{
/// <summary>
/// 设定数据上下文,它一般由构架方法注入
/// </summary>
/// <param name="unitOfWork"></param>
void SetDbContext(IUnitOfWork unitOfWork);
/// <summary>
/// 添加实体并提交到数据服务器
/// </summary>
/// <param name="item">Item to add to repository</param>
void Insert(TEntity item);
/// <summary>
/// 移除实体并提交到数据服务器
/// 如果表存在约束，需要先删除子表信息
/// </summary>
/// <param name="item">Item to delete</param>
void Delete(TEntity item);
/// <summary>
/// 修改实体并提交到数据服务器
/// </summary>
/// <param name="item"></param>
void Update(TEntity item);
/// <summary>
/// 得到指定的实体集合（延时结果集）
/// Get all elements of type {T} in repository
/// </summary>
/// <returns>List of selected elements</returns>
IQueryable<TEntity> GetModel();
/// <summary>
/// 根据主键得到实体
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
TEntity Find(params object[] id);
}
View Code
二 一个扩展操作接口
/// <summary>
/// 扩展的Repository操作规范
/// </summary>
public interface IExtensionRepository<TEntity> :
IRepository<TEntity>,
IOrderableRepository<TEntity>
where TEntity : class
{
/// <summary>
/// 添加集合[集合数目不大时用此方法，超大集合使用BulkInsert]
/// </summary>
/// <param name="item"></param>
void Insert(IEnumerable<TEntity> item);
/// <summary>
/// 修改集合[集合数目不大时用此方法，超大集合使用BulkUpdate]
/// </summary>
/// <param name="item"></param>
void Update(IEnumerable<TEntity> item);
/// <summary>
/// 删除集合[集合数目不大时用此方法，超大集合使用批量删除]
/// </summary>
/// <param name="item"></param>
void Delete(IEnumerable<TEntity> item);
/// <summary>
/// 扩展更新方法，只对EF支持
/// 注意本方法不能和GetModel()一起使用，它的表主键可以通过post或get方式获取
/// </summary>
/// <param name="entity"></param>
void Update<T>(Expression<Action<T>> entity) where T : class;
/// <summary>
/// 根据指定lambda表达式,得到延时结果集
/// </summary>
/// <param name="predicate"></param>
/// <returns></returns>
IQueryable<TEntity> GetModel(Expression<Func<TEntity, bool>> predicate);
/// <summary>
/// 根据指定lambda表达式,得到第一个实体
/// </summary>
/// <param name="predicate"></param>
/// <returns></returns>
TEntity Find(Expression<Func<TEntity, bool>> predicate);
/// <summary>
/// 批量添加，添加之前可以去除自增属性,默认不去除
/// </summary>
/// <param name="item"></param>
/// <param name="isRemoveIdentity"></param>
void BulkInsert(IEnumerable<TEntity> item, bool isRemoveIdentity);
/// <summary>
/// 批量添加
/// </summary>
/// <param name="item"></param>
void BulkInsert(IEnumerable<TEntity> item);
/// <summary>
/// 批量更新
/// </summary>
/// <param name="item"></param>
void BulkUpdate(IEnumerable<TEntity> item, params string[] fieldParams);
/// <summary>
/// 批量删除
/// </summary>
/// <param name="item"></param>
void BulkDelete(IEnumerable<TEntity> item);
}
View Code
三 一个排序操作接口
/// <summary>
/// 提供排序功能的规范
/// </summary>
public interface IOrderableRepository<TEntity> where TEntity : class
{
/// <summary>
/// 带排序的结果集
/// </summary>
/// <param name="orderBy"></param>
/// <returns></returns>
IQueryable<TEntity> GetModel(Action<IOrderable<TEntity>> orderBy);
/// <summary>
/// 根据指定lambda表达式和排序方式,得到延时结果集
/// </summary>
/// <param name="predicate"></param>
/// <returns></returns>
IQueryable<TEntity> GetModel(Action<IOrderable<TEntity>> orderBy, Expression<Func<TEntity, bool>> predicate);
}
View Code
四 基于ef架构的规约查询接口
/// <summary>
/// EF底层构架，关于规约功能的仓储接口
/// </summary>
/// <typeparam name="TEntity"></typeparam>
public interface ISpecificationRepository<TEntity> :
IExtensionRepository<TEntity>
where TEntity : class
{
/// <summary>
/// 根据指定规约,得到延时结果集
/// </summary>
/// <param name="specification"></param>
/// <returns></returns>
IQueryable<TEntity> GetModel(ISpecification<TEntity> specification);
/// <summary>
/// 根据指定规约,得到第一个实体
/// </summary>
/// <param name="specification"></param>
/// <returns></returns>
TEntity Find(ISpecification<TEntity> specification);
/// <summary>
/// 带排序功能的，根据指定规约，得到结果集
/// </summary>
/// <param name="orderBy"></param>
/// <param name="specification"></param>
/// <returns></returns>
IQueryable<TEntity> GetModel(Action<IOrderable<TEntity>> orderBy, EntityFrameworks.Entity.Core.Specification.ISpecification<TEntity> specification);
/// <summary>
/// 保存之后触发
/// Occurs after data saved
/// </summary>
event Action<SavedEventArgs> AfterSaved;
/// <summary>
/// 保存之前触发
/// Occurs before data saved
/// </summary>
event Action<SavedEventArgs> BeforeSaved;
}
View Code
五 基于工作单元的标识接口
/// <summary>
/// 数据上下文标识接口，它对于业务层应该是公开的
/// 它对于实现上下文的方法，它并不关心，可以是linq2sql,ef,ado.net,nhibernate,memory,nosql等
/// </summary>
public interface IUnitOfWork
{
}
View Code
六 基于ef的DbContext上下文的仓储的实现
/// <summary>
/// DbContext上下文仓储功能类，领域上下文可以直接继承它
/// 生命周期：数据上下文的生命周期为一个HTTP请求的结束
/// 相关说明：
/// 1 领域对象使用声明IRepository和IExtensionRepository接口得到不同的操作规范
/// 2 可以直接为上下注入Action<string>的委托实例，用来记录savechanges产生的异常
/// 3 可以订阅BeforeSaved和AfterSaved两个事件，用来在方法提交前与提交后实现代码注入
/// 4 所有领域db上下文都要继承iUnitWork接口，用来实现工作单元，这对于提升程序性能与为重要
/// </summary>
/// <typeparam name="TEntity"></typeparam>
public class DbContextRepository<TEntity> :
ISpecificationRepository<TEntity>
where TEntity : class
{
#region Constructors
public DbContextRepository(IUnitOfWork db, Action<string> logger)
{
UnitWork = db;
Db = (DbContext)db;
Logger = logger;
((IObjectContextAdapter)Db).ObjectContext.CommandTimeout = 0;
}
public DbContextRepository(IUnitOfWork db)
: this(db, null)
{ }
#endregion
#region Properties
/// <summary>
/// 数据上下文
/// </summary>
protected DbContext Db { get; private set; }
/// <summary>
/// 工作单元上下文,子类可以直接使用它
/// </summary>
protected IUnitOfWork UnitWork { get; set; }
/// <summary>
/// Action委托事例，在派生类可以操作它
/// </summary>
protected Action<string> Logger { get; private set; }
#endregion
#region Fields
/// <summary>
/// 数据总数
/// </summary>
int _dataTotalCount = 0;
/// <summary>
/// 数据总页数
/// </summary>
int _dataTotalPages = 0;
/// <summary>
/// 数据页面大小（每次向数据库提交的记录数）
/// </summary>
private const int DataPageSize = 10000;
#endregion
#region Delegates & Event
/// <summary>
/// 保存之后
/// </summary>
public event Action<SavedEventArgs> AfterSaved;
/// <summary>
/// 保存之前
/// </summary>
public event Action<SavedEventArgs> BeforeSaved;
#endregion
#region IRepository<TEntity> 成员
public void SetDbContext(IUnitOfWork unitOfWork)
{
this.Db = (DbContext)unitOfWork;
this.UnitWork = unitOfWork;
}
public virtual void Insert(TEntity item)
{
OnBeforeSaved(new SavedEventArgs(item, SaveAction.Insert));
Db.Entry<TEntity>(item);
Db.Set<TEntity>().Add(item);
this.SaveChanges();
OnAfterSaved(new SavedEventArgs(item, SaveAction.Insert));
}
public virtual void Delete(TEntity item)
{
OnBeforeSaved(new SavedEventArgs(item, SaveAction.Delete));
Db.Set<TEntity>().Attach(item);
Db.Set<TEntity>().Remove(item);
this.SaveChanges();
OnAfterSaved(new SavedEventArgs(item, SaveAction.Delete));
}
public virtual void Update(TEntity item)
{
OnBeforeSaved(new SavedEventArgs(item, SaveAction.Update));
Db.Set<TEntity>().Attach(item);
Db.Entry(item).State = EntityState.Modified;
try
{
this.SaveChanges();
}
catch (System.Data.OptimisticConcurrencyException ex)//并发冲突异常
{
((IObjectContextAdapter)Db).ObjectContext.Refresh(RefreshMode.ClientWins, item);
this.SaveChanges();
}
OnAfterSaved(new SavedEventArgs(item, SaveAction.Update));
}
/// <summary>
/// 子类在实现时，可以重写，加一些状态过滤
/// </summary>
/// <returns></returns>
public virtual IQueryable<TEntity> GetModel()
{
// return Db.Set<TEntity>().AsNoTracking();//对象无法自动添加到上下文中，因为它是使用 NoTracking 合并选项检索的。请在定义此关系之前，将该实体显式附加到 ObjectContext。
return Db.Set<TEntity>();////ObjectStateManager 中已存在具有同一键的对象。ObjectStateManager 无法跟踪具有相同键的多个对象。
}
/// <summary>
/// 得到原生态结果集
/// </summary>
/// <returns></returns>
public IQueryable<TEntity> GetEntities()
{
return Db.Set<TEntity>();
}
#endregion
#region IExtensionRepository<TEntity> 成员
public virtual void Insert(IEnumerable<TEntity> item)
{
item.ToList().ForEach(i =>
{
Db.Entry<TEntity>(i);
Db.Set<TEntity>().Add(i);
});
this.SaveChanges();
}
public virtual void Delete(IEnumerable<TEntity> item)
{
item.ToList().ForEach(i =>
{
Db.Set<TEntity>().Attach(i);
Db.Set<TEntity>().Remove(i);
});
this.SaveChanges();
}
public virtual void Update(IEnumerable<TEntity> item)
{
item.ToList().ForEach(i =>
{
Db.Set<TEntity>().Attach(i);
Db.Entry(i).State = EntityState.Modified;
});
try
{
this.SaveChanges();
}
catch (System.Data.OptimisticConcurrencyException ex)//并发冲突异常
{
((IObjectContextAdapter)Db).ObjectContext.Refresh(RefreshMode.ClientWins, item);
this.SaveChanges();
}
}
public void Update<T>(Expression<Action<T>> entity) where T : class
{
T newEntity = typeof(T).GetConstructor(Type.EmptyTypes).Invoke(null) as T;//建立指定类型的实例
List<string> propertyNameList = new List<string>();
MemberInitExpression param = entity.Body as MemberInitExpression;
foreach (var item in param.Bindings)
{
string propertyName = item.Member.Name;
object propertyValue;
var memberAssignment = item as MemberAssignment;
if (memberAssignment.Expression.NodeType == ExpressionType.Constant)
{
propertyValue = (memberAssignment.Expression as ConstantExpression).Value;
}
else
{
propertyValue = Expression.Lambda(memberAssignment.Expression, null).Compile().DynamicInvoke();
}
typeof(T).GetProperty(propertyName).SetValue(newEntity, propertyValue, null);
propertyNameList.Add(propertyName);
}
try
{
Db.Set<T>().Attach(newEntity);
}
catch (Exception)
{
throw new Exception("本方法不能和GetModel()一起使用，请使用Update(TEntity entity)方法");
}
Db.Configuration.ValidateOnSaveEnabled = false;
var ObjectStateEntry = ((IObjectContextAdapter)Db).ObjectContext.ObjectStateManager.GetObjectStateEntry(newEntity);
propertyNameList.ForEach(x => ObjectStateEntry.SetModifiedProperty(x.Trim()));
try
{
this.SaveChanges();
}
catch (System.Data.OptimisticConcurrencyException ex)//并发冲突异常
{
((IObjectContextAdapter)Db).ObjectContext.Refresh(RefreshMode.ClientWins, newEntity);
this.SaveChanges();
}
}
public TEntity Find(params object[] id)
{
return Db.Set<TEntity>().Find(id);
}
public IQueryable<TEntity> GetModel(Expression<Func<TEntity, bool>> predicate)
{
return GetModel().Where(predicate);
}
public TEntity Find(Expression<Func<TEntity, bool>> predicate)
{
return GetModel(predicate).FirstOrDefault();
}
public void BulkInsert(IEnumerable<TEntity> item)
{
BulkInsert(item, false);
}
public void BulkInsert(IEnumerable<TEntity> item, bool isRemoveIdentity)
{
string startTag = "", endTag = "";
if (isRemoveIdentity)
{
startTag = "SET IDENTITY_INSERT " + typeof(TEntity).Name + " ON;";
endTag = "SET IDENTITY_INSERT " + typeof(TEntity).Name + " OFF;";
}
DataPageProcess(item, (currentItems) =>
{
((IObjectContextAdapter)Db).ObjectContext.CommandTimeout = 0;//永不超时
Db.Database.ExecuteSqlCommand(startTag
+ DoSql(currentItems, SqlType.Insert)
+ endTag);
});
}
public void BulkDelete(IEnumerable<TEntity> item)
{
DataPageProcess(item, (currentItems) =>
{
((IObjectContextAdapter)Db).ObjectContext.CommandTimeout = 0;//永不超时
Db.Database.ExecuteSqlCommand(DoSql(currentItems, SqlType.Delete));
});
}
public void BulkUpdate(IEnumerable<TEntity> item, params string[] fieldParams)
{
DataPageProcess(item, (currentItems) =>
{
((IObjectContextAdapter)Db).ObjectContext.CommandTimeout = 0;//永不超时
Db.Database.ExecuteSqlCommand(DoSql(currentItems, SqlType.Update, fieldParams));
});
}
#endregion
#region ISpecificationRepository<TEntity> 成员
public TEntity Find(ISpecification<TEntity> specification)
{
return GetModel(specification).FirstOrDefault();
}
public IQueryable<TEntity> GetModel(Action<IOrderable<TEntity>> orderBy, ISpecification<TEntity> specification)
{
var linq = new Orderable<TEntity>(GetModel(specification));
orderBy(linq);
return linq.Queryable;
}
public IQueryable<TEntity> GetModel(ISpecification<TEntity> specification)
{
return GetModel().Where(specification.SatisfiedBy());
}
#endregion
#region IOrderableRepository<TEntity>成员
public IQueryable<TEntity> GetModel(Action<IOrderable<TEntity>> orderBy)
{
var linq = new Orderable<TEntity>(GetModel());
orderBy(linq);
return linq.Queryable;
}
public IQueryable<TEntity> GetModel(Action<IOrderable<TEntity>> orderBy, Expression<Func<TEntity, bool>> predicate)
{
var linq = new Orderable<TEntity>(GetModel(predicate));
orderBy(linq);
return linq.Queryable;
}
#endregion
#region Protected Methods
/// <summary>
/// 根据工作单元的IsNotSubmit的属性，去判断是否提交到数据库
/// 一般地，在多个repository类型进行组合时，这个IsNotSubmit都会设为true，即不马上提交，
/// 而对于单个repository操作来说，它的值不需要设置，使用默认的false，将直接提交到数据库，这也保证了操作的原子性。
/// </summary>
protected void SaveChanges()
{
try
{
Db.SaveChanges();
}
catch (System.Data.Entity.Validation.DbEntityValidationException dbEx)//捕获实体验证异常
{
var sb = new StringBuilder();
dbEx.EntityValidationErrors.First().ValidationErrors.ToList().ForEach(i =>
{
sb.AppendFormat("属性为：{0}，信息为：{1}\n\r", i.PropertyName, i.ErrorMessage);
});
if (Logger == null)
throw new Exception(sb.ToString());
Logger(sb.ToString() + "处理时间：" + DateTime.Now);
}
catch (System.Data.OptimisticConcurrencyException ex)//并发冲突异常
{
//保持数据源中对象的现有属性
//Db.Refresh(RefreshMode.StoreWins, person);
// Db.SaveChanges();
}
catch (Exception ex)//捕获所有异常
{
if (Logger == null)//如果没有定义日志功能，就把异常抛出来吧
throw new Exception(ex.Message);
Logger(ex.Message + "处理时间：" + DateTime.Now);
}
}
/// <summary>
/// 计数更新,与SaveChange()是两个SQL链接，走分布式事务
/// 子类可以根据自己的逻辑，去复写
/// tableName:表名
/// param:索引0为主键名，1表主键值，2为要计数的字段，3为增量
/// </summary>
/// <param name="tableName">表名</param>
/// <param name="param">参数列表，索引0为主键名，1表主键值，2为要计数的字段，3为增量</param>
protected virtual void UpdateForCount(string tableName, params object[] param)
{
string sql = "update [" + tableName + "] set [{2}]=ISNULL([{2}],0)+{3} where [{0}]={1}";
var listParasm = new List<object>
{
param[0],
param[1],
param[2],
param[3],
};
Db.Database.ExecuteSqlCommand(string.Format(sql, listParasm.ToArray()));
}
#endregion
#region Virtual Methods
/// <summary>
/// Called after data saved
/// </summary>
/// <param name="e"></param>
protected virtual void OnAfterSaved(SavedEventArgs e)
{
if (AfterSaved != null)
{
AfterSaved(e);
}
}
/// <summary>
/// Called before saved
/// </summary>
/// <param name="e"></param>
protected virtual void OnBeforeSaved(SavedEventArgs e)
{
if (BeforeSaved != null)
{
BeforeSaved(e);
}
}
#endregion
#region Private Methods
/// <summary>
/// 分页进行数据提交的逻辑
/// </summary>
/// <param name="item">原列表</param>
/// <param name="method">处理方法</param>
/// <param name="currentItem">要进行处理的新列表</param>
private void DataPageProcess(IEnumerable<TEntity> item, Action<IEnumerable<TEntity>> method)
{
if (item != null && item.Any())
{
_dataTotalCount = item.Count();
this._dataTotalPages = item.Count() / DataPageSize;
if (_dataTotalCount % DataPageSize > 0)
_dataTotalPages += 1;
for (int pageIndex = 1; pageIndex <= _dataTotalPages; pageIndex++)
{
var currentItems = item.Skip((pageIndex - 1) * DataPageSize).Take(DataPageSize).ToList();
method(currentItems);
}
}
}
private static string GetEqualStatment(string fieldName, int paramId, Type pkType)
{
if (pkType.IsValueType)
return string.Format("{0} = {1}", fieldName, GetParamTag(paramId));
return string.Format("{0} = '{1}'", fieldName, GetParamTag(paramId));
}
private static string GetParamTag(int paramId)
{
return "{" + paramId + "}";
}
/// <summary>
/// 得到实体键EntityKey
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <returns></returns>
protected ReadOnlyMetadataCollection<EdmMember> GetPrimaryKey()
{
EntitySetBase primaryKey = ((IObjectContextAdapter)Db).ObjectContext.GetEntitySet(typeof(TEntity));
if (primaryKey == null)
return null;
ReadOnlyMetadataCollection<EdmMember> arr = primaryKey.ElementType.KeyMembers;
return arr;
}
/// <summary>
/// 构建Update语句串
/// 注意：如果本方法过滤了int,decimal类型更新为０的列，如果希望更新它们需要指定FieldParams参数
/// </summary>
/// <param name="entity">实体列表</param>
/// <param name="fieldParams">要更新的字段</param>
/// <returns></returns>
private Tuple<string, object[]> CreateUpdateSql(TEntity entity, params string[] fieldParams)
{
if (entity == null)
throw new ArgumentException("The database entity can not be null.");
var pkList = GetPrimaryKey().Select(i => i.Name).ToList();
var entityType = entity.GetType();
var tableFields = new List<PropertyInfo>();
if (fieldParams != null && fieldParams.Count() > 0)
{
tableFields = entityType.GetProperties().Where(i => fieldParams.Contains(i.Name, new StringComparisonIgnoreCase())).ToList();
}
else
{
tableFields = entityType.GetProperties().Where(i =>
!pkList.Contains(i.Name)
&& i.GetValue(entity, null) != null
&& !i.PropertyType.IsEnum
&& !(i.PropertyType == typeof(ValueType) && Convert.ToInt64(i.GetValue(entity, null)) == 0)
&& !(i.PropertyType == typeof(DateTime) && Convert.ToDateTime(i.GetValue(entity, null)) == DateTime.MinValue)
&& i.PropertyType != typeof(EntityState)
&& i.GetCustomAttributes(false).Where(j => j.GetType() == typeof(NavigationAttribute)) != null//过滤导航属性
&& (i.PropertyType.IsValueType || i.PropertyType == typeof(string))
).ToList();
}
//过滤主键，航行属性，状态属性等
if (pkList == null || pkList.Count == 0)
throw new ArgumentException("The Table entity have not a primary key.");
var arguments = new List<object>();
var builder = new StringBuilder();
foreach (var change in tableFields)
{
if (pkList.Contains(change.Name))
continue;
if (arguments.Count != 0)
builder.Append(", ");
builder.Append(change.Name + " = {" + arguments.Count + "}");
if (change.PropertyType == typeof(string)
|| change.PropertyType == typeof(DateTime)
|| change.PropertyType == typeof(DateTime?)
|| change.PropertyType == typeof(bool?)
|| change.PropertyType == typeof(bool))
arguments.Add("'" + change.GetValue(entity, null).ToString().Replace("'", "char(39)") + "'");
else
arguments.Add(change.GetValue(entity, null));
}
if (builder.Length == 0)
throw new Exception("没有任何属性进行更新");
builder.Insert(0, " UPDATE " + string.Format("[{0}]", entityType.Name) + " SET ");
builder.Append(" WHERE ");
bool firstPrimaryKey = true;
foreach (var primaryField in pkList)
{
if (firstPrimaryKey)
firstPrimaryKey = false;
else
builder.Append(" AND ");
object val = entityType.GetProperty(primaryField).GetValue(entity, null);
Type pkType = entityType.GetProperty(primaryField).GetType();
builder.Append(GetEqualStatment(primaryField, arguments.Count, pkType));
arguments.Add(val);
}
return new Tuple<string, object[]>(builder.ToString(), arguments.ToArray());
}
/// <summary>
/// 构建Delete语句串
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <param name="entity"></param>
/// <returns></returns>
private Tuple<string, object[]> CreateDeleteSql(TEntity entity)
{
if (entity == null)
throw new ArgumentException("The database entity can not be null.");
Type entityType = entity.GetType();
List<string> pkList = GetPrimaryKey().Select(i => i.Name).ToList();
if (pkList == null || pkList.Count == 0)
throw new ArgumentException("The Table entity have not a primary key.");
var arguments = new List<object>();
var builder = new StringBuilder();
builder.Append(" Delete from " + string.Format("[{0}]", entityType.Name));
builder.Append(" WHERE ");
bool firstPrimaryKey = true;
foreach (var primaryField in pkList)
{
if (firstPrimaryKey)
firstPrimaryKey = false;
else
builder.Append(" AND ");
Type pkType = entityType.GetProperty(primaryField).GetType();
object val = entityType.GetProperty(primaryField).GetValue(entity, null);
builder.Append(GetEqualStatment(primaryField, arguments.Count, pkType));
arguments.Add(val);
}
return new Tuple<string, object[]>(builder.ToString(), arguments.ToArray());
}
/// <summary>
/// 构建Insert语句串
/// 主键为自增时，如果主键值为0，我们将主键插入到SQL串中
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <param name="entity"></param>
/// <returns></returns>
private Tuple<string, object[]> CreateInsertSql(TEntity entity)
{
if (entity == null)
throw new ArgumentException("The database entity can not be null.");
Type entityType = entity.GetType();
var table = entityType.GetProperties().Where(i => i.PropertyType != typeof(EntityKey)
&& i.PropertyType != typeof(EntityState)
&& i.Name != "IsValid"
&& i.GetValue(entity, null) != null
&& !i.PropertyType.IsEnum
&& i.GetCustomAttributes(false).Where(j => j.GetType() == typeof(NavigationAttribute)) != null
&& (i.PropertyType.IsValueType || i.PropertyType == typeof(string))).ToArray();//过滤主键，航行属性，状态属性等
var pkList = new List<string>();
if (GetPrimaryKey() != null)//有时主键可能没有设计，这对于添加操作是可以的
pkList = GetPrimaryKey().Select(i => i.Name).ToList();
var arguments = new List<object>();
var fieldbuilder = new StringBuilder();
var valuebuilder = new StringBuilder();
fieldbuilder.Append(" INSERT INTO " + string.Format("[{0}]", entityType.Name) + " (");
foreach (var member in table)
{
if (pkList.Contains(member.Name) && Convert.ToString(member.GetValue(entity, null)) == "0")
continue;
object value = member.GetValue(entity, null);
if (value != null)
{
if (arguments.Count != 0)
{
fieldbuilder.Append(", ");
valuebuilder.Append(", ");
}
fieldbuilder.Append(member.Name);
if (member.PropertyType == typeof(string)
|| member.PropertyType == typeof(DateTime)
|| member.PropertyType == typeof(DateTime?)
|| member.PropertyType == typeof(Boolean?)
|| member.PropertyType == typeof(Boolean)
)
valuebuilder.Append("'{" + arguments.Count + "}'");
else
valuebuilder.Append("{" + arguments.Count + "}");
if (value is string)
value = value.ToString().Replace("'", "char(39)");
arguments.Add(value);
}
}
fieldbuilder.Append(") Values (");
fieldbuilder.Append(valuebuilder.ToString());
fieldbuilder.Append(");");
return new Tuple<string, object[]>(fieldbuilder.ToString(), arguments.ToArray());
}
/// <summary>
/// /// <summary>
/// 执行SQL，根据SQL操作的类型
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <param name="list"></param>
/// <param name="sqlType"></param>
/// <returns></returns>
/// </summary>
/// <param name="list"></param>
/// <param name="sqlType"></param>
/// <returns></returns>
private string DoSql(IEnumerable<TEntity> list, SqlType sqlType)
{
return DoSql(list, sqlType, null);
}
/// <summary>
/// 执行SQL，根据SQL操作的类型
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <param name="list"></param>
/// <param name="sqlType"></param>
/// <returns></returns>
private string DoSql(IEnumerable<TEntity> list, SqlType sqlType, params string[] fieldParams)
{
var sqlstr = new StringBuilder();
switch (sqlType)
{
case SqlType.Insert:
list.ToList().ForEach(i =>
{
Tuple<string, object[]> sql = CreateInsertSql(i);
sqlstr.AppendFormat(sql.Item1, sql.Item2);
});
break;
case SqlType.Update:
list.ToList().ForEach(i =>
{
Tuple<string, object[]> sql = CreateUpdateSql(i, fieldParams);
sqlstr.AppendFormat(sql.Item1, sql.Item2);
});
break;
case SqlType.Delete:
list.ToList().ForEach(i =>
{
Tuple<string, object[]> sql = CreateDeleteSql(i);
sqlstr.AppendFormat(sql.Item1, sql.Item2);
});
break;
default:
throw new ArgumentException("请输入正确的参数");
}
return sqlstr.ToString();
}
/// <summary>
/// SQL操作类型
/// </summary>
protected enum SqlType
{
Insert,
Update,
Delete,
}
#endregion
}
View Code
以上六大部分就是我最新的EF架构的核心了，事实上，EF只是实现数据持久化的一种方式，在我的架构中还提到了XmlRepository,RedisRepository,Linq2SqlRepository等等，对于仓储这块感兴趣的同学，可以与我一起去讨论！我很希望有一天，我的底层
架构有这样一个功能，那就是自动去选择我的数据库，如我的数据库有db1,db2.....dbN，它们之间的数据是同步的（集群），我能通过ＥＦ来实现我用哪台数据服务器，想想就很美，哈哈！
回到目录
作者：仓储大叔，张占岭，
荣誉：微软MVP
