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