public void BatchInsert(IEnumerable <TEntity> entities, int batchSize = 1000, Action <int> completePercentage = null)
{
var batcher = context.Database.Provider.GetService <IBatcherProvider>();
if (batcher == null)
{
throw new EntityPersistentException(SR.GetString(SRKind.NotSupportBatcher), null);
}
var syntax = context.Database.Provider.GetService <ISyntaxProvider>();
var rootType = typeof(TEntity).GetRootType();
var tableName = string.Empty;
entities.ForEach(s => EntityPersistentSubscribePublisher.OnBeforeCreate(s));
//if (Environment != null)
{
// tableName = DbUtility.FormatByQuote(syntax, Environment.GetVariableTableName(rootType));
}
//else
{
var metadata = EntityMetadataUnity.GetEntityMetadata(rootType);
tableName = DbUtility.FormatByQuote(syntax, metadata.TableName);
}
batcher.Insert(context.Database, entities, tableName, batchSize, completePercentage);
}
/// <summary>
/// 对实体集合进行批量操作。
/// </summary>
/// <param name="instances">要操作的实体序列。</param>
/// <param name="fnOperation">实体操作表达式，权提供 Insert、Update 和 Delete 操作。</param>
/// <returns>影响的实体数。</returns>
public int Batch(IEnumerable <TEntity> instances, Expression <Func <IRepository <TEntity>, TEntity, int> > fnOperation)
{
var operateName = OperateFinder.Find(fnOperation);
var eventType = GetBeforeEventType(operateName);
return(EntityPersistentSubscribePublisher.OnBatch(instances.Cast <IEntity>(), eventType, () => repositoryProxy.Batch(instances, fnOperation)));
}
/// <summary>
/// 将一个新的实体对象创建到库。
/// </summary>
/// <param name="entity">要创建的实体对象。</param>
public void Create(IEntity entity)
{
ValidationUnity.Validate(entity);
EntityPersistentSubscribePublisher.OnBeforeCreate(entity);
try
{
Batch(() =>
{
var isSucc = false;
entity.TryLockModifing(() =>
{
isSucc = InternalCreate(entity);
UpdateRelations(entity);
});
if (isSucc)
{
EntityPersistentSubscribePublisher.OnAfterCreate(entity);
entity.SetState(EntityState.Unchanged);
}
});
}
catch (DbException exp)
{
throw new EntityPersistentException(SR.GetString(SRKind.FailInEntityCreate), exp);
}
}
/// <summary>
/// 将指定的实体对象从库中移除。
/// </summary>
/// <param name="entity">要移除的实体对象。</param>
/// <param name="logicalDelete">是否为逻辑删除。</param>
/// <returns>影响的实体数。</returns>
public int Delete(TEntity entity, bool logicalDelete = true)
{
Guard.ArgumentNull(entity, nameof(entity));
int func() => repositoryProxy.Delete(entity, logicalDelete);
return(context.Options.NotifyEvents ?
EntityPersistentSubscribePublisher.OnRemove(entity, func) : func());
}
/// <summary>
/// 对实体集合进行批量操作。
/// </summary>
/// <param name="instances">要操作的实体序列。</param>
/// <param name="fnOperation">实体操作表达式，权提供 Insert、Update 和 Delete 操作。</param>
/// <returns>影响的实体数。</returns>
public int Batch(IEnumerable <TEntity> instances, Expression <Func <IRepository <TEntity>, TEntity, int> > fnOperation)
{
var operateName = OperateFinder.Find(fnOperation);
var eventType = GetBeforeEventType(operateName);
instances.ForEach(s => EntityPersistentSubscribePublisher.RaiseEvent(s, eventType));
return(repositoryProxy.Batch(instances, fnOperation));
}
/// <summary>
/// 根据主键值将对象从库中移除。
/// </summary>
/// <param name="primaryValues">一组主键值。</param>
/// <returns>影响的实体数。</returns>
public int Delete(params PropertyValue[] primaryValues)
{
var ret = repositoryProxy.Delete(primaryValues, true);
if (ret > 0)
{
EntityPersistentSubscribePublisher.RaiseEvent <TEntity>(EntityPersistentEventType.AfterRemove);
}
return(ret);
}
/// <summary>
/// 根据主键值将对象从库中移除。
/// </summary>
/// <param name="primaryValues">一组主键值。</param>
/// <param name="logicalDelete">是否为逻辑删除。</param>
/// <returns>影响的实体数。</returns>
public int Delete(object[] primaryValues, bool logicalDelete = true)
{
var ret = repositoryProxy.Delete(primaryValues, logicalDelete);
if (ret > 0)
{
EntityPersistentSubscribePublisher.RaiseEvent <TEntity>(EntityPersistentEventType.AfterRemove);
}
return(ret);
}
/// <summary>
/// 使用一个参照的实体对象更新满足条件的一序列对象。
/// </summary>
/// <param name="entity">更新的参考对象。</param>
/// <param name="predicate">用于测试每个元素是否满足条件的函数。</param>
/// <returns>影响的实体数。</returns>
public int Update(TEntity entity, Expression <Func <TEntity, bool> > predicate)
{
int result;
if ((result = repositoryProxy.Update(entity, predicate)) > 0)
{
EntityPersistentSubscribePublisher.OnAfterUpdate(entity);
}
return(result);
}
/// <summary>
/// 将满足条件的一组对象从库中移除。
/// </summary>
/// <param name="predicate">用于测试每个元素是否满足条件的函数。</param>
/// <param name="logicalDelete">是否为逻辑删除</param>
/// <returns>影响的实体数。</returns>
public int Delete(Expression <Func <TEntity, bool> > predicate, bool logicalDelete = true)
{
var ret = repositoryProxy.Delete(predicate, logicalDelete);
if (ret > 0)
{
EntityPersistentSubscribePublisher.RaiseEvent <TEntity>(EntityPersistentEventType.AfterRemove);
}
return(ret);
}
/// <summary>
/// 使用一个累加器更新满足条件的一序列对象。
/// </summary>
/// <param name="calculator">一个计算器表达式。</param>
/// <param name="predicate">用于测试每个元素是否满足条件的函数。</param>
/// <returns>影响的实体数。</returns>
public int Update(Expression <Func <TEntity, TEntity> > calculator, Expression <Func <TEntity, bool> > predicate)
{
var ret = repositoryProxy.Update(calculator, predicate);
if (ret > 0)
{
EntityPersistentSubscribePublisher.RaiseEvent <TEntity>(EntityPersistentEventType.AfterUpdate);
}
return(ret);
}
/// <summary>
/// 使用一个参照的实体对象更新满足条件的一序列对象。
/// </summary>
/// <param name="entity">更新的参考对象。</param>
/// <param name="predicate">用于测试每个元素是否满足条件的函数。</param>
/// <returns>影响的实体数。</returns>
public int Update(TEntity entity, Expression <Func <TEntity, bool> > predicate)
{
var ret = repositoryProxy.Update(entity, predicate);
if (ret > 0 && context.Options.NotifyEvents)
{
EntityPersistentSubscribePublisher.RaiseEvent <TEntity>(EntityPersistentEventType.AfterUpdate);
}
return(ret);
}
/// <summary>
/// 根据主键值将对象从库中移除。
/// </summary>
/// <param name="primaryValues">一组主键值。</param>
/// <param name="logicalDelete">是否为逻辑删除。</param>
/// <returns>影响的实体数。</returns>
public int Delete(PropertyValue[] primaryValues, bool logicalDelete = true)
{
var ret = repositoryProxy.Delete(primaryValues, logicalDelete);
if (ret > 0 && context.Options.NotifyEvents)
{
EntityPersistentSubscribePublisher.RaiseEvent <TEntity>(EntityPersistentEventType.AfterRemove);
}
return(ret);
}
/// <summary>
/// 根据实体的状态，插入或更新实体对象。
/// </summary>
/// <param name="entity">要保存的实体对象。</param>
/// <returns>影响的实体数。</returns>
public int InsertOrUpdate(TEntity entity)
{
Guard.ArgumentNull(entity, nameof(entity));
if (entity.EntityState == EntityState.Attached)
{
return(EntityPersistentSubscribePublisher.OnCreate(entity, () => repositoryProxy.Insert(entity)));
}
else
{
return(EntityPersistentSubscribePublisher.OnUpdate(entity, () => repositoryProxy.Update(entity)));
}
}
public int Delete(TEntity entity, bool logicalDelete = true)
{
EntityPersistentSubscribePublisher.OnBeforeRemove(entity);
int result;
if ((result = Queryable.RemoveEntity(entity, logicalDelete)) > 0)
{
EntityPersistentSubscribePublisher.OnAfterRemove(entity);
}
return(result);
}
/// <summary>
/// 将一个新的实体对象创建到库。
/// </summary>
/// <param name="entity">要创建的实体对象。</param>
/// <returns>影响的实体数。</returns>
public int Insert(TEntity entity)
{
Guard.ArgumentNull(entity, nameof(entity));
if (context.Options.ValidateEntity)
{
ValidationUnity.Validate(entity);
}
int func() => repositoryProxy.Insert(entity);
return(context.Options.NotifyEvents ?
EntityPersistentSubscribePublisher.OnCreate(entity, func) : func());
}
/// <summary>
/// 对实体集合进行批量操作。
/// </summary>
/// <param name="instances">要操作的实体序列。</param>
/// <param name="fnOperation">实体操作表达式，权提供 Insert、Update 和 Delete 操作。</param>
/// <returns>影响的实体数。</returns>
public int Batch(IEnumerable <TEntity> instances, Expression <Func <IRepository <TEntity>, TEntity, int> > fnOperation)
{
if (instances.IsNullOrEmpty())
{
return(-1);
}
var operateName = OperateFinder.Find(fnOperation);
var eventType = GetBeforeEventType(operateName);
int func() => repositoryProxy.Batch(instances, fnOperation);
return(context.Options.NotifyEvents ?
EntityPersistentSubscribePublisher.OnBatch(instances.Cast <IEntity>(), eventType, func) :
func());
}
public int Insert(TEntity entity)
{
EntityPersistentSubscribePublisher.OnBeforeCreate(entity);
ValidationUnity.Validate(entity);
var trans = CheckRelationHasModified(entity);
if (trans)
{
context.Database.BeginTransaction();
}
int result = 0;
try
{
if ((result = Queryable.CreateEntity(entity)) > 0)
{
entity.As <IEntityPersistentEnvironment>(s => s.Environment = context.Environment);
entity.As <IEntityPersistentInstanceContainer>(s => s.InstanceName = context.InstanceName);
HandleRelationProperties(entity);
EntityPersistentSubscribePublisher.OnAfterCreate(entity);
}
if (trans)
{
context.Database.CommitTransaction();
}
}
catch (Exception exp)
{
if (trans)
{
context.Database.RollbackTransaction();
}
throw exp;
}
return(result);
}
public int Update(TEntity entity)
{
EntityPersistentSubscribePublisher.OnBeforeUpdate(entity);
ValidationUnity.Validate(entity);
var trans = CheckRelationHasModified(entity);
if (trans)
{
context.Database.BeginTransaction();
}
int result = 0;
try
{
if ((result = Queryable.UpdateEntity(entity)) > 0)
{
EntityPersistentSubscribePublisher.OnAfterUpdate(entity);
}
HandleRelationProperties(entity);
if (trans)
{
context.Database.CommitTransaction();
}
}
catch (Exception exp)
{
if (trans)
{
context.Database.RollbackTransaction();
}
throw exp;
}
return(result);
}
/// <summary>
/// 将指定的实体对象从库中移除。
/// </summary>
/// <param name="entity">要移除的实体对象。</param>
/// <param name="fakeProperty">标识假删除的属性。</param>
/// <param name="fake">如果具有 IsDeletedKey 属性，则提供对数据假删除的支持。</param>
/// <exception cref="NullReferenceException">对象内部的 Database 为 null。</exception>
/// <exception cref="ArgumentNullException"><paramref name="entity"/> 参数为 null。</exception>
public void Remove(IEntity entity, IProperty fakeProperty, bool fake = true)
{
EntityPersistentSubscribePublisher.OnBeforeRemove(entity);
try
{
Batch(() =>
{
var parameters = new ParameterCollection();
var context = CreateContext(parameters);
var canFake = fakeProperty != null && fake;
var sql = canFake ? EntityPersistentQueryBuilder.BuildUpdateFakeDeleteQuery(context, entity, fakeProperty)
: EntityPersistentQueryBuilder.BuildDeleteQuery(context, entity);
var isSucc = false;
entity.TryLockModifing(() =>
{
if (!sql.IsNullOrEmpty())
{
isSucc = database.ExecuteNonQuery(sql, parameters) > 0;
}
UpdateRelations(entity);
});
if (isSucc)
{
EntityPersistentSubscribePublisher.OnAfterRemove(entity);
entity.SetState(EntityState.Unchanged);
}
});
}
catch (DbException exp)
{
throw new EntityPersistentException(SR.GetString(SRKind.FailInEntityRemove), exp);
}
}
/// <summary>
/// 更新实体对象的修改。
/// </summary>
/// <param name="entity">要更新的实体对象。</param>
public void Update(IEntity entity)
{
ValidationUnity.Validate(entity);
EntityPersistentSubscribePublisher.OnBeforeUpdate(entity);
try
{
Batch(() =>
{
var parameters = new ParameterCollection();
var context = CreateContext(parameters);
var sql = EntityPersistentQueryBuilder.BuildUpdateQuery(context, entity);
var isSucc = false;
entity.TryLockModifing(() =>
{
if (!sql.IsNullOrEmpty())
{
isSucc = database.ExecuteNonQuery(sql, parameters) > 0;
}
UpdateRelations(entity);
});
if (isSucc)
{
EntityPersistentSubscribePublisher.OnAfterUpdate(entity);
entity.SetState(EntityState.Unchanged);
}
});
}
catch (Exception exp)
{
throw new EntityPersistentException(SR.GetString(SRKind.FailInEntityUpdate), exp);
}
}
/// <summary>
/// 将一个新的实体对象创建到库。
/// </summary>
/// <param name="entity">要创建的实体对象。</param>
/// <returns>影响的实体数。</returns>
public int Insert(TEntity entity)
{
Guard.ArgumentNull(entity, nameof(entity));
return(EntityPersistentSubscribePublisher.OnCreate(entity, () => repositoryProxy.Insert(entity)));
}
/// <summary>
/// 将指定的实体对象从库中移除。
/// </summary>
/// <param name="entity">要移除的实体对象。</param>
/// <param name="logicalDelete">是否为逻辑删除。</param>
/// <returns>影响的实体数。</returns>
public int Delete(TEntity entity, bool logicalDelete = true)
{
Guard.ArgumentNull(entity, nameof(entity));
return(EntityPersistentSubscribePublisher.OnRemove(entity, () => repositoryProxy.Delete(entity, logicalDelete)));
}
