/// <summary> /// 使用一个 <see cref="MemberInitExpression"/> 表达式插入新的对象。 /// </summary> /// <param name="creator">一个构造实例并成员绑定的表达式。</param> /// <returns>如果主键是自增类型,则为主键值,否则为影响的实体数。</returns> public virtual int Insert(Expression <Func <TEntity> > creator) { var entity = EntityProxyManager.GetType(ContextType, typeof(TEntity)).New <TEntity>(); entity.InitByExpression(creator); return(Insert(entity)); }
/// <summary> /// 使用初始化函数更新满足条件的一序列对象。 /// </summary> /// <param name="initializer">一个初始化实体成员绑定的函数。</param> /// <param name="predicate">用于测试每个元素是否满足条件的函数。</param> /// <returns>影响的实体数。</returns> public virtual int Update(Action <TEntity> initializer, Expression <Func <TEntity, bool> > predicate) { Guard.ArgumentNull(initializer, nameof(initializer)); var entity = EntityProxyManager.GetType(ContextType, typeof(TEntity)).New <TEntity>(); initializer(entity); return(predicate == null?Update(entity) : Update(entity, predicate)); }
/// <summary> /// 异步的,使用一个 <see cref="MemberInitExpression"/> 表达式更新满足条件的一序列对象。 /// </summary> /// <param name="creator">一个构造实例并成员绑定的表达式。</param> /// <param name="predicate">用于测试每个元素是否满足条件的函数。</param> /// <param name="cancellationToken">取消操作的通知。</param> /// <returns>影响的实体数。</returns> public async virtual Task <int> UpdateAsync(Expression <Func <TEntity> > creator, Expression <Func <TEntity, bool> > predicate, CancellationToken cancellationToken = default) { cancellationToken.ThrowIfCancellationRequested(); var entity = EntityProxyManager.GetType(ContextType, typeof(TEntity)).New <TEntity>(); entity.InitByExpression(creator); return(predicate == null ? await UpdateAsync(entity, cancellationToken) : await UpdateAsync(entity, predicate, cancellationToken)); }
/// <summary> /// 使用初始化函数将一个新的实体对象插入到库。 /// </summary> /// <param name="initializer">一个初始化实体成员绑定的函数。</param> /// <returns>如果主键是自增类型,则为主键值,否则为影响的实体数。</returns> public virtual int Insert(Action <TEntity> initializer) { Guard.ArgumentNull(initializer, nameof(initializer)); var entity = EntityProxyManager.GetType(ContextType, typeof(TEntity)).New <TEntity>(); initializer(entity); return(Insert(entity)); }
/// <summary> /// 异步的,使用一个 <see cref="MemberInitExpression"/> 表达式插入新的对象。 /// </summary> /// <param name="creator">一个构造实例并成员绑定的表达式。</param> /// <param name="cancellationToken">取消操作的通知。</param> /// <returns>如果主键是自增类型,则为主键值,否则为影响的实体数。</returns> public async virtual Task <int> InsertAsync(Expression <Func <TEntity> > creator, CancellationToken cancellationToken = default) { cancellationToken.ThrowIfCancellationRequested(); var entity = EntityProxyManager.GetType(ContextType, typeof(TEntity)).New <TEntity>(); entity.InitByExpression(creator); return(await InsertAsync(entity, cancellationToken)); }
/// <summary> /// 异步的,使用初始化函数更新满足条件的一序列对象。 /// </summary> /// <param name="initializer">一个初始化实体成员绑定的函数。</param> /// <param name="predicate">用于测试每个元素是否满足条件的函数。</param> /// <param name="cancellationToken">取消操作的通知。</param> /// <returns>影响的实体数。</returns> public async virtual Task <int> UpdateAsync(Action <TEntity> initializer, Expression <Func <TEntity, bool> > predicate, CancellationToken cancellationToken = default) { Guard.ArgumentNull(initializer, nameof(initializer)); cancellationToken.ThrowIfCancellationRequested(); var entity = EntityProxyManager.GetType(ContextType, typeof(TEntity)).New <TEntity>(); initializer(entity); return(predicate == null ? await UpdateAsync(entity, cancellationToken) : await UpdateAsync(entity, predicate, cancellationToken)); }
/// <summary> /// 异步的,使用初始化函数将一个新的实体对象插入到库。 /// </summary> /// <param name="initializer">一个初始化实体成员绑定的函数。</param> /// <param name="cancellationToken">取消操作的通知。</param> /// <returns>如果主键是自增类型,则为主键值,否则为影响的实体数。</returns> public async virtual Task <int> InsertAsync(Action <TEntity> initializer, CancellationToken cancellationToken = default) { Guard.ArgumentNull(initializer, nameof(initializer)); cancellationToken.ThrowIfCancellationRequested(); var entity = EntityProxyManager.GetType(ContextType, typeof(TEntity)).New <TEntity>(); initializer(entity); return(await InsertAsync(entity, cancellationToken)); }
/// <summary> /// 构造一个代理对象。 /// </summary> /// <param name="applyDefaultValue">是否应用默认值。</param> /// <returns></returns> public static TEntity New(bool applyDefaultValue) { var proxyType = EntityProxyManager.GetType(typeof(TEntity)); var entity = proxyType.New <TEntity>(); if (applyDefaultValue) { return((TEntity)entity.ApplyDefaultValue()); } return(entity); }
/// <summary> /// 构造一个实体代理对象。 /// </summary> /// <param name="context"></param> /// <param name="entityType">实体类型。</param> /// <param name="applyDefaultValue">是否应用默认值。</param> /// <returns></returns> public static IEntity New <TContext>(this TContext context, Type entityType, bool applyDefaultValue) where TContext : EntityContext { var provider = (IProvider)context.GetService(typeof(IProvider)); var proxyType = EntityProxyManager.GetType(typeof(TContext), entityType); var entity = proxyType.New <IEntity>(); if (applyDefaultValue) { return(entity.ApplyDefaultValue()); } return(entity); }
/// <summary> /// 构造一个代理对象。 /// </summary> /// <returns></returns> public static TEntity New() { var proxyType = EntityProxyManager.GetType(typeof(TEntity)); return(proxyType.New <TEntity>()); }
/// <summary> /// 将 Json 转换为 <paramref name="dataType"/> 的代理对象。 /// </summary> /// <param name="serializer"></param> /// <param name="dataType"></param> /// <param name="json"></param> /// <returns></returns> public override object ReadJson(JsonSerializer serializer, Type dataType, string json) { var proxyType = EntityProxyManager.GetType(dataType); return(serializer.Deserialize(json, proxyType)); }