internal void Read()
{
this._setter = new EntityPropertySetter(this.Repository.EntityMeta);
if (this.ResultEntityList == null)
{
this.ResultEntityList = this.Repository.NewList();
}
this.ReadCore();
}
internal EntityList QueryList(Action<IPropertyQuery> queryBuider, Predicate<Entity> filter = null, EntityList entityList = null)
{
var query = this.CreatePropertyQuery();
if (queryBuider != null) queryBuider(query);
return this.QueryList(new PropertyQueryArgs
{
PropertyQuery = query,
Filter = filter,
EntityList = entityList
});
}
/// <summary>
/// 把实体列表对应的 json 转换为 EntityList 对象。
/// </summary>
/// <param name="jEntityList"></param>
/// <param name="repository">如果没有显式指定 Repository，则会根据 json 中的 _model 属性来查找对应的实体仓库。</param>
/// <param name="resultEntityList">如果显式指定 Repository，则会把转换的实体对象都加入到这个列表中。</param>
/// <returns></returns>
internal static EntityList JsonToEntity(JObject jEntityList, EntityRepository repository = null, EntityList resultEntityList = null)
{
if (repository == null)
{
var modelProperty = jEntityList.Property("_model");
if (modelProperty == null) { throw new NotSupportedException("实体列表对应的 Json 应该有 _model 属性。"); }
var model = modelProperty.Value.CastTo<JValue>().Value.CastTo<string>();
var clientEntity = ClientEntities.Find(model);
repository = RF.Find(clientEntity.EntityType);
}
ListReader reader = repository.SupportTree ? new TreeEntityListReader() : new EntityListReader() as ListReader;
reader.Repository = repository;
reader.ChangeSet = jEntityList;
reader.ResultEntityList = resultEntityList;
reader.Read();
return reader.ResultEntityList;
}
private void SerializeList(EntityList entityList)
{
var totalCount = entityList.TotalCount;
if (totalCount > 0)
{
_writer.WriteStartObject();
this.WritePropertyName(TotalCountProperty);
_writer.WriteValue(totalCount);
this.WritePropertyName(EntityListProperty);
}
_writer.WriteStartArray();
foreach (var entity in entityList)
{
this.SerializeEntity(entity);
}
_writer.WriteEndArray();
if (totalCount > 0)
{
_writer.WriteEndObject();
}
}
/// <summary>
/// 数据层 - 提交树节点
/// </summary>
/// <param name="list">The list.</param>
/// <param name="markSaved">if set to <c>true</c> [mark saved].</param>
private void SubmitTreeList(EntityList list, bool markSaved)
{
//先保存所有添加、变更的节点。
for (int i = 0, c = list.Count; i < c; i++)
{
var item = list[i];
if (item.IsDirty)
{
//这里的 markSaved 传入的应该是 false，否则会把待删除列表中的元素清空。
this.SubmitItem(item, false, true);
}
}
//然后再保存所有删除的节点。
this.SubmitTreeDeletedItems(list, markSaved);
}
private static Entity FindOrCreate(EntityList list, JObject jEntity)
{
var id = TryGetId(jEntity);
Entity child = null;
if (id != null)
{
child = list.Find(id, true);
}
if (child == null)
{
child = list.GetRepository().New();
list.Add(child);
}
return child;
}
/// <summary>
/// 保存根对象列表
/// </summary>
private void SubmitList(EntityList list, bool markSaved)
{
var toDelete = list.DeletedListField;
if (toDelete != null)
{
for (int i = 0, c = toDelete.Count; i < c; i++)
{
var child = toDelete[i];
this.SubmitItem(child, markSaved, false);
}
list.DeletedListField = null;
}
for (int i = 0, c = list.Count; i < c; i++)
{
var item = list[i];
if (item.IsDirty)
{
this.SubmitItem(item, markSaved, false);
}
}
}
/// <summary>
/// 将查询出来的实体列表类型转换为与仓库查询方法返回值一致的类型。
/// </summary>
/// <param name="list"></param>
/// <returns></returns>
protected static object ReturnForRepository(EntityList list)
{
return(ReturnForRepository(list, FinalDataPortal.CurrentIEQC.QueryType));
}
/// <summary>
/// 保存某个实体列表。
/// </summary>
/// <param name="entityList">The entity list.</param>
public static void Save(EntityList entityList)
{
entityList.GetRepository().Save(entityList);
}
/// <summary>
/// 对实体列表中每一个实体都贪婪加载出它的所有引用实体。
/// </summary>
/// <param name="list"></param>
/// <param name="refProperty">贪婪加载的引用属性。</param>
/// <param name="eagerLoadProperties">所有还需要贪婪加载的属性。</param>
private void EagerLoadRef(EntityList list, IRefProperty refProperty, List <ConcreteProperty> eagerLoadProperties)
{
var refIdProperty = refProperty.RefIdProperty;
//查询一个大的实体集合，包含列表中所有实体所需要的所有引用实体。
var idList = new List <object>(10);
list.EachNode(e =>
{
var refId = e.GetRefNullableId(refIdProperty);
if (refId != null && idList.All(id => !id.Equals(refId)))
{
idList.Add(refId);
}
return(false);
});
if (idList.Count > 0)
{
var targetRepo = RepositoryFactoryHost.Factory.FindByEntity(refProperty.RefEntityType);
var refList = targetRepo.GetByIdList(idList.ToArray());
//继续递归加载它的贪婪属性。
this.EagerLoad(refList, eagerLoadProperties);
#region 把实体全部放到排序列表中
//由于数据量可能较大，所以需要进行排序后再顺序加载。
IList <Entity> sortedList = null;
if (_repository.SupportTree)
{
var tmp = new List <Entity>(list.Count);
list.EachNode(p =>
{
tmp.Add(p);
return(false);
});
sortedList = tmp.OrderBy(e => e.GetRefNullableId(refIdProperty)).ToList();
}
else
{
sortedList = list.OrderBy(e => e.GetRefNullableId(refIdProperty)).ToList();
}
#endregion
#region 使用一次主循环就把所有的子实体都加载到父实体中。
//一次循环就能完全加载的前提是因为父集合按照 Id 排序，子集合按照父 Id 排序。
//把大的实体集合，根据 Id，设置到每一个实体上。
var refEntityProperty = refProperty.RefEntityProperty;
int refListIndex = 0, refListCount = refList.Count;
var refEntity = refList[refListIndex];
for (int i = 0, c = sortedList.Count; i < c; i++)
{
var entity = sortedList[i];
var refId = entity.GetRefNullableId(refIdProperty);
if (refId != null)
{
//必须把该对象处理完成后，才能跳出下面的循环。
while (true)
{
if (object.Equals(refId, refEntity.Id))
{
entity.LoadProperty(refEntityProperty, refEntity);
break;
}
else
{
//检测下一个引用实体。
refListIndex++;
//所有父集合已经加载完毕，退出整个循环。
if (refListIndex >= refListCount)
{
i = c;
break;
}
refEntity = refList[refListIndex];
}
}
}
}
#endregion
}
}
/// <summary>
/// 对实体列表中每一个实体都贪婪加载出它的所有子实体。
/// </summary>
/// <param name="list"></param>
/// <param name="listProperty">贪婪加载的列表子属性。</param>
/// <param name="eagerLoadProperties">所有还需要贪婪加载的属性。</param>
private void EagerLoadChildren(EntityList list, IListProperty listProperty, List <ConcreteProperty> eagerLoadProperties)
{
//查询一个大的实体集合，包含列表中所有实体所需要的所有子实体。
var idList = new List <object>(10);
list.EachNode(e =>
{
idList.Add(e.Id);
return(false);
});
if (idList.Count > 0)
{
var targetRepo = RepositoryFactoryHost.Factory.FindByEntity(listProperty.ListEntityType);
var allChildren = targetRepo.GetByParentIdList(idList.ToArray());
//继续递归加载它的贪婪属性。
this.EagerLoad(allChildren, eagerLoadProperties);
//把大的实体集合，根据父实体 Id，分拆到每一个父实体的子集合中。
var parentProperty = targetRepo.FindParentPropertyInfo(true).ManagedProperty as IRefProperty;
var parentIdProperty = parentProperty.RefIdProperty;
#region 把父实体全部放到排序列表中
//由于数据量可能较大，所以需要进行排序后再顺序加载。
IList <Entity> sortedList = null;
if (_repository.SupportTree)
{
var sortedParents = new List <Entity>(list.Count);
list.EachNode(p =>
{
sortedParents.Add(p);
return(false);
});
sortedList = sortedParents.OrderBy(e => e.Id).ToList();
}
else
{
sortedList = list.OrderBy(e => e.Id).ToList();
}
#endregion
#region 使用一次主循环就把所有的子实体都加载到父实体中。
//一次循环就能完全加载的前提是因为父集合按照 Id 排序，子集合按照父 Id 排序。
int pIndex = 0, pLength = sortedList.Count;
var parent = sortedList[pIndex];
var children = targetRepo.NewList();
for (int i = 0, c = allChildren.Count; i < c; i++)
{
var child = allChildren[i];
var childPId = child.GetRefId(parentIdProperty);
//必须把该子对象处理完成后，才能跳出下面的循环。
while (true)
{
if (object.Equals(childPId, parent.Id))
{
children.Add(child);
break;
}
else
{
//检测下一个父实体。
pIndex++;
//所有父集合已经加载完毕，退出整个循环。
if (pIndex >= pLength)
{
i = c;
break;
}
//把整理好的子集合，加载到父实体中。
children.SetParentEntity(parent);
parent.LoadProperty(listProperty, children);
//并同时更新变量。
parent = sortedList[pIndex];
children = targetRepo.NewList();
}
}
}
if (children.Count > 0)
{
children.SetParentEntity(parent);
}
parent.LoadProperty(listProperty, children);
//如果子集合处理完了，父集合还没有循环到最后，那么需要把余下的父实体的子集合都加载好。
pIndex++;
while (pIndex < pLength)
{
parent = sortedList[pIndex];
parent.LoadProperty(listProperty, targetRepo.NewList());
pIndex++;
}
#endregion
}
}
/// <summary> /// 子类重写此方法，查询从持久层加载列表的具体实现。 /// </summary> /// <param name="args">The arguments.</param> /// <param name="entityList">The entity list.</param> protected abstract void QueryDataCore(EntityQueryArgs args, EntityList entityList);
private void ReadToBatchRecur(EntityList entityList, EntityBatch batch)
{
var deletedList = entityList.DeletedListField;
if (deletedList != null)
{
for (int i = 0, c = deletedList.Count; i < c; i++)
{
var entity = deletedList[i];
this.ReadToBatchRecur(entity, batch);
}
}
for (int i = 0, c = entityList.Count; i < c; i++)
{
var entity = entityList[i];
this.ReadToBatchRecur(entity, batch);
}
}
/// <summary>
/// 通过聚合SQL加载整个聚合对象列表。
/// </summary>
/// <param name="list">The list.</param>
/// <param name="sql">聚合SQL</param>
/// <param name="loadOptions">聚合加载选项</param>
public void LoadEntities(EntityList list, string sql, LoadOptionSelector loadOptions)
{
var loader = new AggregateEntityLoader(loadOptions.InnerDescriptor);
loader.Query(list, sql);
}
