/// <summary> /// 异步的,将指定的实体对象从库中移除。 /// </summary> /// <param name="entity">要移除的实体对象。</param> /// <param name="logicalDelete">是否为逻辑删除。</param> /// <param name="cancellationToken">取消操作的通知。</param> /// <returns>影响的实体数。</returns> public async Task <int> DeleteAsync(TEntity entity, bool logicalDelete = true, CancellationToken cancellationToken = default) { Guard.ArgumentNull(entity, nameof(entity)); return(await EntityPersistentSubscribeManager.OnRemoveAsync(options.NotifyEvents, entity, () => repositoryProxy.DeleteAsync(entity, logicalDelete, cancellationToken))); }
/// <summary> /// 根据实体的状态,插入或更新实体对象。 /// </summary> /// <param name="entity">要保存的实体对象。</param> /// <returns>影响的实体数。</returns> public int InsertOrUpdate(TEntity entity) { Guard.ArgumentNull(entity, nameof(entity)); var properties = PropertyUnity.GetPrimaryProperties(typeof(TEntity)); var isNew = entity.EntityState == EntityState.Attached; if (isNew && properties.Any(s => !PropertyValue.IsEmptyOrDefault(entity.GetValue(s)))) { var parExp = Expression.Parameter(typeof(TEntity), "s"); var equalExp = properties.Select(s => Expression.Equal(Expression.MakeMemberAccess(parExp, s.Info.ReflectionInfo), Expression.Constant(entity.GetValue(s)))).Aggregate(Expression.And); var lambdaExp = Expression.Lambda <Func <TEntity, bool> >(equalExp, parExp); isNew = !this.Any(lambdaExp); } if (options.NotifyEvents) { if (isNew) { return(EntityPersistentSubscribeManager.OnCreate(entity, () => repositoryProxy.Insert(entity))); } else { return(EntityPersistentSubscribeManager.OnUpdate(entity, () => repositoryProxy.Update(entity))); } } return(isNew ? repositoryProxy.Insert(entity) : repositoryProxy.Update(entity)); }
/// <summary> /// 异步的,将一个新的实体对象创建到库。 /// </summary> /// <param name="entity">要创建的实体对象。</param> /// <param name="cancellationToken">取消操作的通知。</param> /// <returns>如果主键是自增类型,则为主键值,否则为影响的实体数。</returns> public async Task <int> InsertAsync(TEntity entity, CancellationToken cancellationToken = default) { Guard.ArgumentNull(entity, nameof(entity)); return(await EntityPersistentSubscribeManager.OnCreateAsync(options.NotifyEvents, entity, () => repositoryProxy.InsertAsync(HandleValidate(entity), cancellationToken))); }
/// <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(EntityPersistentSubscribeManager.OnRemove(options.NotifyEvents, entity, () => repositoryProxy.DeleteAsync(entity, logicalDelete).Result)); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { SerializeOption.GlobalConverters.Add(new LightEntityJsonConverter()); services.AddFireasy(Configuration) .AddIoc(ContainerUnity.GetContainer()) //添加 appsettings.json 里的 ioc 配置 .AddEntityContext <DbContext>(options => { options.NotifyEvents = true; //此项设为 true 时, 上面的实体持久化订阅通知才会触发 }); //注册实体持久化的订阅通知 EntityPersistentSubscribeManager.AddSubscriber(subject => new EntitySubscriber().Accept(subject)); services.AddMvc() .AddSessionStateTempDataProvider() .ConfigureFireasyMvc(options => { //options.JsonSerializeOption.Converters.Add(new LightEntityJsonConverter()); }) .ConfigureEasyUI(); services.AddSession() .AddSessionRevive <SessionReviveNotification>(); services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme) .AddCookie(options => { options.LoginPath = new PathString("/login"); }); }
/// <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(options.NotifyEvents ? EntityPersistentSubscribeManager.OnRemove(entity, func) : func()); }
/// <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 && options.NotifyEvents) { EntityPersistentSubscribeManager.Publish <TEntity>(EntityPersistentEventType.AfterRemove); } return(ret); }
/// <summary> /// 异步的,使用一个累加器更新满足条件的一序列对象。 /// </summary> /// <param name="calculator">一个计算器表达式。</param> /// <param name="predicate">用于测试每个元素是否满足条件的函数。</param> /// <param name="cancellationToken">取消操作的通知。</param> /// <returns>影响的实体数。</returns> public async Task <int> UpdateAsync(Expression <Func <TEntity, TEntity> > calculator, Expression <Func <TEntity, bool> > predicate, CancellationToken cancellationToken = default) { var ret = await repositoryProxy.UpdateAsync(calculator, predicate, cancellationToken); if (ret > 0 && options.NotifyEvents) { EntityPersistentSubscribeManager.Publish <TEntity>(EntityPersistentEventType.AfterUpdate); } return(ret); }
/// <summary> /// 异步的,将满足条件的一组对象从库中移除。 /// </summary> /// <param name="predicate">用于测试每个元素是否满足条件的函数。</param> /// <param name="logicalDelete">是否为逻辑删除</param> /// <param name="cancellationToken">取消操作的通知。</param> /// <returns>影响的实体数。</returns> public async Task <int> DeleteAsync(Expression <Func <TEntity, bool> > predicate, bool logicalDelete = true, CancellationToken cancellationToken = default) { var ret = await repositoryProxy.DeleteAsync(predicate, logicalDelete); if (ret > 0 && options.NotifyEvents) { EntityPersistentSubscribeManager.Publish <TEntity>(EntityPersistentEventType.AfterRemove); } return(ret); }
/// <summary> /// 异步的,根据主键值将对象从库中移除。 /// </summary> /// <param name="primaryValues">一组主键值。</param> /// <param name="logicalDelete">是否为逻辑删除。</param> /// <param name="cancellationToken">取消操作的通知。</param> /// <returns>影响的实体数。</returns> public async Task <int> DeleteAsync(PropertyValue[] primaryValues, bool logicalDelete = true, CancellationToken cancellationToken = default) { var ret = await repositoryProxy.DeleteAsync(primaryValues, logicalDelete); if (ret > 0 && options.NotifyEvents) { EntityPersistentSubscribeManager.Publish <TEntity>(EntityPersistentEventType.AfterRemove); } return(ret); }
/// <summary> /// 异步的,根据主键值将对象从库中移除。 /// </summary> /// <param name="primaryValues">一组主键值。</param> /// <returns>影响的实体数。</returns> public async Task <int> DeleteAsync(params PropertyValue[] primaryValues) { var ret = await repositoryProxy.DeleteAsync(primaryValues, default); if (ret > 0 && options.NotifyEvents) { EntityPersistentSubscribeManager.Publish <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 && options.NotifyEvents) { EntityPersistentSubscribeManager.Publish <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 && options.NotifyEvents) { EntityPersistentSubscribeManager.Publish <TEntity>(EntityPersistentEventType.AfterUpdate); } return(ret); }
/// <summary> /// 根据主键值将对象从库中移除。 /// </summary> /// <param name="primaryValues">一组主键值。</param> /// <returns>影响的实体数。</returns> public int Delete(params PropertyValue[] primaryValues) { var ret = repositoryProxy.Delete(primaryValues, true); if (ret > 0 && options.NotifyEvents) { EntityPersistentSubscribeManager.Publish <TEntity>(EntityPersistentEventType.AfterRemove); } return(ret); }
/// <summary> /// 异步的,对实体集合进行批量操作。 /// </summary> /// <param name="instances">要操作的实体序列。</param> /// <param name="fnOperation">实体操作表达式,权提供 Insert、Update 和 Delete 操作。</param> /// <param name="cancellationToken">取消操作的通知。</param> /// <returns>影响的实体数。</returns> public async Task <int> BatchAsync(IEnumerable <TEntity> instances, Expression <Func <IRepository <TEntity>, TEntity, int> > fnOperation, CancellationToken cancellationToken = default) { if (instances.IsNullOrEmpty()) { return(-1); } var operateName = OperateFinder.Find(fnOperation); var eventType = GetBeforeEventType(operateName); return(await EntityPersistentSubscribeManager.OnBatchAsync(options.NotifyEvents, instances.Cast <IEntity>(), eventType, () => repositoryProxy.BatchAsync(instances, fnOperation, cancellationToken))); }
/// <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 && options.NotifyEvents) { EntityPersistentSubscribeManager.Publish <TEntity>(EntityPersistentEventType.AfterUpdate); } System.Console.WriteLine("I[date"); return(ret); }
public void TestSubscriberForUpdate() { EntityPersistentSubscribeManager.AddSubscriber(subject => { new EntitySubscriber().Accept(subject); }); using (var db = new DbContext()) { var order = db.Orders.FirstOrDefault(); order.ShipName = "2"; db.Orders.Update(order); } }
/// <summary> /// 更新一个实体对象。 /// </summary> /// <param name="entity">实体对象。</param> /// <returns>影响的实体数。</returns> public int Update(TEntity entity) { Guard.ArgumentNull(entity, nameof(entity)); if (context.Options.ValidateEntity) { ValidationUnity.Validate(entity); } int func() => repositoryProxy.Update(entity); return(context.Options.NotifyEvents ? EntityPersistentSubscribeManager.OnUpdate(entity, func) : func()); }
/// <summary> /// 将一个新的实体对象创建到库。 /// </summary> /// <param name="entity">要创建的实体对象。</param> /// <returns>影响的实体数。</returns> public int Insert(TEntity entity) { Guard.ArgumentNull(entity, nameof(entity)); if (options.ValidateEntity) { ValidationUnity.Validate(entity); } int func() => repositoryProxy.Insert(entity); return(options.NotifyEvents ? EntityPersistentSubscribeManager.OnCreate(entity, func) : func()); }
public void TestSubscriberForUpdateLinq() { EntityPersistentSubscribeManager.AddSubscriber(subject => { new EntitySubscriber().Accept(subject); }); using (var db = new DbContext()) { db.Orders.Update(new Orders { ShipName = "1" }, s => s.ShipName == "1"); } }
/// <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(options.NotifyEvents ? EntityPersistentSubscribeManager.OnBatch(instances.Cast <IEntity>(), eventType, func) : func()); }
/// <summary> /// 根据实体的状态,插入或更新实体对象。 /// </summary> /// <param name="entity">要保存的实体对象。</param> /// <returns>影响的实体数。</returns> public int InsertOrUpdate(TEntity entity) { Guard.ArgumentNull(entity, nameof(entity)); if (options.NotifyEvents) { if (entity.EntityState == EntityState.Attached) { return(EntityPersistentSubscribeManager.OnCreate(entity, () => repositoryProxy.Insert(entity))); } else { return(EntityPersistentSubscribeManager.OnUpdate(entity, () => repositoryProxy.Update(entity))); } } return(entity.EntityState == EntityState.Attached ? repositoryProxy.Insert(entity) : repositoryProxy.Update(entity)); }
public void TestSubscriberForBatch() { EntityPersistentSubscribeManager.AddSubscriber(subject => { new EntitySubscriber().Accept(subject); }); using (var db = new DbContext()) { var list = new List <Depts>(); for (var i = 0; i < 3; i++) { var d = Depts.New(); d.DeptID = i + 50; d.DeptName = "a" + i; list.Add(d); } list[1].DeptCode = "test"; db.Depts.Batch(list, (u, s) => u.Update(s)); } }