void Reset()
{
animator = GetComponent <Animator>();
renderer = GetComponent <SpriteRenderer>();
rigid = GetComponent <Rigidbody2D>();
//_hitable = GetComponent<HitableBullet>();
//hitableRay = GetComponent<HitableBulletRay>();
hitableCircleCast = GetComponent <HitableBulletCircleCast>();
hitableTrigger = GetComponent <HitableBulletTrigger>();
hitableRaycast = GetComponent <HitableBulletRayCast>();
shootable = GetComponent <ShootableBullet>();
moveable = GetComponent <MoveableBullet>();
ownerable = GetComponent <OwnerableBullet>();
timeLimitable = GetComponent <TimeLimitableBullet>();
damageable = GetComponent <DamageableBullet>();
spawnable = GetComponent <SpawnableBullet>();
shakeable = GetComponent <ShakeableBullet>();
disapearable = GetComponent <DisapearableBullet>();
guideable = GetComponent <GuideableBullet>();
orderable = GetComponent <Orderable>();
spinable = GetComponent <SpinableBullet>();
polygon = GetComponent <PolygonCollider2D>();
circle = GetComponent <CircleCollider2D>();
physics = GetComponent <PhysicsCollider>();
cachedTransform = transform;
}
public IQueryable <TEntity> GetModel(Action <IRepositories.Commons.IOrderable <TEntity> > orderBy, System.Linq.Expressions.Expression <Func <TEntity, bool> > predicate)
{
var linq = new Orderable <TEntity>(GetModel(predicate));
orderBy(linq);
return(linq.Queryable);
}
public IPageOfItems <Submission> GetSubmissions(string formName = null, int?skip = null, int?take = null)
{
var query = _submissionRepository.Table;
if (!String.IsNullOrWhiteSpace(formName))
{
query = query.Where(x => x.FormName == formName);
}
query = new Orderable <Submission>(query).Desc(x => x.CreatedUtc).Queryable;
var totalItemCount = query.Count();
if (skip != null && take.GetValueOrDefault() > 0)
{
query = query.Skip(skip.Value).Take(take.GetValueOrDefault());
}
return(new PageOfItems <Submission>(query)
{
PageNumber = skip.GetValueOrDefault() * take.GetValueOrDefault(),
PageSize = take ?? Int32.MaxValue,
TotalItemCount = totalItemCount
});
}
public IQueryable <T> GetAll(Expression <Func <T, bool> > where, Action <Orderable <T> > order, int pageIndex, int pageSize, ref int totalRecord)
{
var query = this.Table;
query = query.Where(where);
var orderable = new Orderable <T>(query);
order(orderable);
query = orderable.Queryable;
if (totalRecord <= 0)
{
totalRecord = query.Count();
}
int pages = totalRecord / pageSize;
if (totalRecord % pageSize > 0)
{
pages++;
}
query = query.Skip((pageIndex - 1) * pageSize).Take(pageSize);
return(query);
}
/// <summary>
/// 筛选满足条件的对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="predicate">条件</param>
/// <param name="order">排序</param>
/// <returns></returns>
public static IQueryable <T> Fetch <T>(Expression <Func <T, bool> > predicate, Action <Orderable <T> > order) where T : class, new()
{
var orderable = new Orderable <T>(Fetch(predicate));
order(orderable);
return(orderable.Queryable);
}
/// <summary>
/// 根据查询条件获取排序后的数据
/// </summary>
/// <param name="predicate">查询条件</param>
/// <param name="order">排序规则</param>
/// <param name="unitOfWork">工作单元</param>
/// <typeparam name="T">实体类型</typeparam>
/// <returns>符合条件的枚举</returns>
public static IEnumerable <T> Fetch <T>(this IUnitOfWork unitOfWork, Expression <Func <T, bool> > predicate, Action <Orderable <T> > order) where T : class
{
var query = unitOfWork.Query <T>().Where(predicate);
Orderable <T> orderable = new Orderable <T>(query);
return(orderable.Queryable);
}
public IEnumerable <T> Query(Expression <Func <T, bool> > predicate, Action <Orderable <T> > order, int skip, int count)
{
var orderable = new Orderable <T>(Query(predicate).AsQueryable <T>());
order(orderable);
return(orderable.Queryable.Skip(skip).Take(count));
}
public IQueryable <TEntity> GetModel(Action <IRepositories.Commons.IOrderable <TEntity> > orderBy, Specification.ISpecification <TEntity> specification)
{
var linq = new Orderable <TEntity>(GetModel(specification));
orderBy(linq);
return(linq.Queryable);
}
void Reset()
{
moveable = GetComponent <MoveableUnit>();
stopBeforeAttackable = GetComponent <StopBeforeAttackableUnit>();
stopAfterAttackable = GetComponent <StopAfterAttackableUnit>();
dontStopAttackable = GetComponent <DontStopAttackableUnit>();
enemyTargetable = GetComponent <EnemyTargetableUnit>();
friendlyTargetable = GetComponent <FriendlyTargetableUnit>();
randomMoveable = GetComponent <RandomMoveableUnit>();
rushMoveable = GetComponent <RushMoveableUnit>();
restRushMoveable = GetComponent <RestRushMoveableUnit>();
followMoveable = GetComponent <FollowMoveableUnit>();
boss0Moveable = GetComponent <Boss0MoveableUnit>();
damageable = GetComponent <DamageableUnit>();
hpable = GetComponent <HpableUnit>();
mpable = GetComponent <MpableUnit>();
deathable = GetComponent <DeathableUnit>();
effectable = GetComponent <EffectableUnit>();
timeLimitable = GetComponent <TimeLimitableUnit>();
orderable = GetComponent <Orderable>();
followable = GetComponent <FollowableUnit>();
animator = GetComponent <Animator>();
rigid = GetComponent <Rigidbody2D>();
renderer = GetComponent <SpriteRenderer>();
collider = GetComponent <Collider2D>();
tackleable = GetComponent <TackleableUnit>();
cachedTransform = transform;
shadow = GetComponentInChildren <ShadowController>();
}
public virtual IQueryable <T> Fetch(Expression <Func <T, bool> > expression, Action <Orderable <T> > order)
{
var orderable = new Orderable <T>(FetchWithQueryable(expression));
order(orderable);
return(orderable.Queryable);
}
public IQueryable <T> Fetch(Expression <Func <T, bool> > predicate, Action <Orderable <T> > order)
{
var orderable = new Orderable <T>(Fetch(predicate));
order(orderable);
return(orderable.Queryable);
}
public IQueryable <T> Find(Expression <Func <T, bool> > exp, Action <Orderable <T> > order, ref int totalRecord, int pageIndex = 1, int pageSize = 10, string orderby = "")
{
var query = this.Table;
query = query.Where(exp);
var orderable = new Orderable <T>(query);
order(orderable);
query = orderable.Queryable;
if (totalRecord <= 0)
{
totalRecord = query.Count();
}
int pages = totalRecord / pageSize;
if (totalRecord % pageSize > 0)
{
pages++;
}
query = query.Skip((pageIndex - 1) * pageSize).Take(pageSize);
return(query);
}
public IQueryable <TEntity> GetModel(Action <IRepositories.IOrderable <TEntity> > orderBy)
{
var linq = new Orderable <TEntity>(GetModel());
orderBy(linq);
return(linq.Queryable);
}
public override Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
if (For != null)
{
output.Attributes.Add("data-data", For.Name);
//output.Content.Append(For?.Metadata.GetShortName() ?? For?.Metadata.GetDisplayName());
output.Content.Append(For?.Metadata.GetDisplayName() ?? For?.Metadata.GetDisplayName());
}
if (Renderfunction != null)
{
output.Attributes.Add("data-render", Renderfunction);
}
if (RenderArg != null)
{
output.Attributes.Add("data-render-arg", RenderArg);
}
if (Orderable != null)
{
output.Attributes.Add("data-orderable", Orderable.ToString().ToLower());
}
if (Searchable != null)
{
output.Attributes.Add("data-searchable", Searchable.ToString().ToLower());
}
return(Task.FromResult(0));
}
public IQueryable <TEntity> GetModel(Action <IOrderable <TEntity> > orderBy, Expression <Func <TEntity, bool> > predicate)
{
var linq = new Orderable <TEntity>(GetModel(predicate));
orderBy(linq);
return(linq.Queryable);
}
public IEnumerable <T> Query(Expression <Func <T, bool> > predicate, Action <Orderable <T> > order)
{
var orderable = new Orderable <T>(Query(predicate).AsQueryable <T>());
order(orderable);
return(orderable.Queryable);
}
public IQueryable <TEntity> GetModel(Action <IRepositories.IOrderable <TEntity> > orderBy, System.Linq.Expressions.Expression <Func <TEntity, bool> > predicate)
{
var queryable = GetModel().Where(predicate).AsQueryable();
var linq = new Orderable <TEntity>(queryable);
orderBy(linq);
return(linq.Queryable);
}
public IQueryable <TEntity> GetModel(Action <IOrderable <TEntity> > orderBy, ISpecification <TEntity> specification)
{
var queryable = GetModel().Where(specification.SatisfiedBy()).AsQueryable();
var linq = new Orderable <TEntity>(queryable);
orderBy(linq);
return(linq.Queryable);
}
/// <summary>
/// 查询
/// </summary>
/// <param name="predicate">查询条件</param>
/// <param name="order">排序</param>
/// <returns>IQueryable类型的实体集合</returns>
public IQueryable <T> Fetch(Expression <Func <T, bool> > predicate, Action <Orderable <T> > order)
{
if (order == null)
{
return(Table.Where(predicate));
}
var orderable = new Orderable <T>(Table.Where(predicate));
order(orderable);
return(orderable.Queryable);
}
public virtual IEnumerable <T> GetPaged(Expression <Func <T, bool> > predicate, Action <IOrderable <T> > order, int pageIndex, int pageSize)
{
int skip = pageIndex * pageSize;
Orderable <T> orderable = new Orderable <T>(Set <T>().Where(predicate));
order(orderable);
return(orderable.AsQueryable()
.Skip(skip)
.Take(pageSize));
}
public virtual IQueryable <T> Fetch(Expression <Func <T, bool> > predicate, Action <Orderable <T> > order)
{
var result = Fetch(predicate);
if (order == null)
{
return(result);
}
var orderable = new Orderable <T>(result);
order(orderable);
return(orderable.Queryable);
}
public IQueryable <T> FindBy(Expression <Func <T, bool> > where, Action <Orderable <T> > order)
{
var query = this.Table;
query = query.Where(where);
var orderable = new Orderable <T>(query);
order(orderable);
query = orderable.Queryable;
return(query);
}
private IEnumerable <T> DataOrder(int pageIndex, int pageSize, IEnumerable <T> datasource,
Action <IOrderable <T> > orderExpression)
{
var orders = new Orderable <T>(datasource);
if (orderExpression != null)
{
orderExpression(orders);
}
//排序获取当前页的数据
datasource = orders.Queryable.Skip <T>(pageSize * (pageIndex - 1)).Take(pageSize);
return(datasource);
}
public object GetDataTablesObject(bool serverSide = false)
{
return(new
{
data = Key,
defaultContent = DefaultContent ?? "<span class='st-text'>null/empty</i>",
orderable = Orderable.IsClient(serverSide),
searchable = Searchable.IsClient(serverSide),
sumTotal = SumTotal,
visible = !Hidden && !Invisible,
tag = Tag,
className = ClassName,
mType = Type.GetCustomValue(),
mFilterValues = FilterValues
});
}
public IEnumerable <T> Fetch(Expression <Func <T, bool> > predicate, Action <Orderable <T> > order)
{
try
{
if (order == null)
{
throw new NullReferenceException("排序不能为空!");
}
var orderable = new Orderable <T>(Fetch(predicate));
order(orderable);
return(orderable.Queryable);
}
catch (Exception ex)
{
return(HandleException <IEnumerable <T> >(string.Format("查询实体({0})失败", EType.Name), ex));
}
}
private IEnumerable <T> GetPagedActiveOrDeleted(Expression <Func <T, bool> > predicate, Action <IOrderable <T> > orderAction, int pageIndex, int pageSize, bool isActiveOrDeleted)
{
int skip = pageIndex * pageSize;
ParameterExpression itemParameter = Expression.Parameter(typeof(T), "item");
Expression <Func <T, bool> > whereExpression = Expression.Lambda <Func <T, bool> >
(
Expression.And(
predicate,
Expression.Equal(Expression.Property(itemParameter, "IsDeleted"), Expression.Constant(isActiveOrDeleted))
), itemParameter);
Orderable <T> orderable = new Orderable <T>(Set <T>().Where(whereExpression));
orderAction(orderable);
return(orderable.AsQueryable()
.Skip(skip)
.Take(pageSize));
}
public static OrderItem OrderItem(this Orderable orderable)
{
return(orderable.OrderItems.Single());
}
