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))); }