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