public DataObjectList Query(LoadPlan loadPlan)
{
DataObjectList listInstance = this.CreateListInstance();
this.Session.LoadData(loadPlan, listInstance, (DataId[])null, "");
return(listInstance);
}
public DataObjectList Query(LoadPlan loadPlan, params DataId[] ids)
{
DataObjectList listInstance = this.CreateListInstance();
this.Session.LoadData(loadPlan, listInstance, ids, (string)null);
return(listInstance);
}
private LoadPlan CreatePlanFromString(string loadPlan)
{
XmlDocument xmlDocument = XmlUtils.LoadDocumentFromXml("<root>" + loadPlan + "</root>");
LoadPlanBuilder loadPlanBuilder = new LoadPlanBuilder(this.Session);
LoadPlan loadPlan1 = loadPlanBuilder.BuildPlan(this.Class, (XmlNode)xmlDocument.DocumentElement);
loadPlanBuilder.ProcessObjectViewRequests();
return(loadPlan1);
}
public DataObject QueryObject(LoadPlan loadPlan, DataId id)
{
DataObjectList listInstance = this.CreateListInstance();
this.Session.LoadData(loadPlan, listInstance, new DataId[1]
{
id
}, (string)null);
return(listInstance.Count != 0 ? listInstance[0] : this.Session[loadPlan.Class].NullObject);
}
internal static LoadPlan UseExistingOrCreateNew(LoadPlan plan, MetadataClass cls)
{
if (plan.Class == cls)
{
return(plan);
}
LoadPlan loadPlan = new LoadPlan(cls);
loadPlan.MergeWith(plan);
return(loadPlan);
}
public bool Contains(LoadPlan dst, LoadPlan src)
{
for (int index = 0; index < this.DstPlans.Count; ++index)
{
if (this.DstPlans[index] == dst && this.SrcPlans[index] == src)
{
return(true);
}
}
return(false);
}
public DataObjectList Query(
LoadPlan loadPlan,
string condition,
params object[] paramArray)
{
DataObjectList listInstance = this.CreateListInstance();
this.Session.TraceQueryStarted(this.Class);
this.Session.LoadData(loadPlan, listInstance, (DataId[])null, condition, paramArray);
this.Session.TraceQueryFinished();
return(listInstance);
}
internal LoadPlan GetLoadPlan(DataSession session)
{
if (this.FOnDemandLoadPlan != null)
{
return(this.FOnDemandLoadPlan);
}
this.FOnDemandLoadPlan = new LoadPlan(this.FObjectView.Class);
for (int index = 0; index < this.FParamLoaders.Count; ++index)
{
this.FParamLoaders[index].PrepareLoadPlan(this.FOnDemandLoadPlan, session);
}
return(this.FOnDemandLoadPlan);
}
internal ObjectLoader EnsureObjectLoader(LoadPlan plan)
{
for (int index = 0; index < this.ObjectLoaders.Count; ++index)
{
ObjectLoader objectLoader = this.ObjectLoaders[index];
if (objectLoader.BasePlan == plan)
{
return(objectLoader);
}
}
ObjectLoader objectLoader1 = new ObjectLoader(plan);
this.ObjectLoaders.Add(objectLoader1);
objectLoader1.Prepare(this);
return(objectLoader1);
}
private AssociationRefLoadPlan EnsureAssociationRef(
MetadataAssociationRef assRef,
LoadPlan plan,
LoadPlan.MergedPlans mergedPlans)
{
for (int index = 0; index < this.Links.Count; ++index)
{
AssociationRefLoadPlan link = this.Links[index];
if (link.Ref == assRef)
{
link.Plan.MergeWith(plan, mergedPlans);
return(link);
}
}
AssociationRefLoadPlan associationRefLoadPlan = new AssociationRefLoadPlan(assRef, plan);
this.Links.Add((object)associationRefLoadPlan);
return(associationRefLoadPlan);
}
private ChildRefLoadPlan EnsureChildRef(
MetadataChildRef childRef,
LoadPlan plan,
LoadPlan.MergedPlans mergedPlans)
{
for (int index = 0; index < this.Childs.Count; ++index)
{
ChildRefLoadPlan child = this.Childs[index];
if (child.ChildRef == childRef)
{
child.Plan.MergeWith(plan, mergedPlans);
return(child);
}
}
ChildRefLoadPlan childRefLoadPlan = new ChildRefLoadPlan(childRef, plan);
this.Childs.Add((object)childRefLoadPlan);
return(childRefLoadPlan);
}
private void CheckComplete()
{
if (this.FIsComplete)
{
return;
}
if (this.Object.IsNull)
{
this.FIsComplete = true;
}
else
{
DataStorage storage = this.Object.Storage;
DataSession masterSession = this.Session.MasterSession;
if (masterSession != null)
{
DataObjectChildList childs = masterSession[storage.Class][this.Object.Id].GetChilds(this.ChildRef);
DataStorage dataStorage = this.Session[this.ChildRef.ChildClass];
MetadataProperty property = this.ChildRef.AggregationRef.Association.Property;
for (int index = 0; index < childs.Count; ++index)
{
DataObject untypedValue = (DataObject)dataStorage[childs[index].Id][property].UntypedValue;
}
this.FIsComplete = true;
}
else if (storage.IsChildListCompleted(this.ChildRef))
{
this.FIsComplete = true;
}
else
{
this.Session.TraceUnplannedChildrenLoading(this.ChildRef);
LoadPlan plan = new LoadPlan(storage.Class);
plan.EnsureChildRef(this.ChildRef, new LoadPlan(this.ChildRef.ChildClass));
storage.Session.LoadData(plan, (DataObjectList)null, new DataId[1]
{
this.Object.Id
}, (string)null);
}
}
}
public override void PrepareLoadPlan(LoadPlan plan, DataSession session)
{
LoadPlanList loadPlanList1 = new LoadPlanList();
loadPlanList1.Add(plan);
LoadPlanList loadPlanList2 = loadPlanList1;
foreach (Navigator navigator in this.FNavigation)
{
LoadPlanList navigationPlans = new LoadPlanList();
foreach (LoadPlan sourcePlan in (List <LoadPlan>)loadPlanList2)
{
navigator.GetNavigationLoadPlans(session, sourcePlan, navigationPlans);
}
loadPlanList2 = navigationPlans;
}
foreach (LoadPlan plan1 in (List <LoadPlan>)loadPlanList2)
{
this.FMemberValueGetter.PrepareLoadPlan(plan1, session);
}
}
internal void MergeWith(LoadPlan plan, LoadPlan.MergedPlans mergedPlans)
{
if (mergedPlans != null)
{
if (mergedPlans.Contains(this, plan))
{
return;
}
mergedPlans.Add(this, plan);
}
for (int index = 0; index < plan.Data.Count; ++index)
{
string name = plan.Data[index].Name;
MetadataProperty propertyMetadata = this.Class.Properties.Need(name);
if (!propertyMetadata.IsData)
{
throw new DataException(string.Format("Ошибка слияния планов загрузки.\nКласс '{0}' не содержит свойство данных '{1}'.", (object)this.Class.Name, (object)name));
}
this.EnsureDataProperty(propertyMetadata);
}
for (int index = 0; index < plan.Links.Count; ++index)
{
AssociationRefLoadPlan link = plan.Links[index];
string name = link.Ref.Association.Property.Name;
MetadataProperty metadataProperty = this.Class.Properties.Need(name);
if (!metadataProperty.IsLink)
{
throw new DataException(string.Format("Ошибка слияния планов загрузки.\nКласс '{0}' не содержит свойство связи '{1}'.", (object)this.Class.Name, (object)name));
}
this.EnsureAssociationRef(metadataProperty.Association.Refs.Need(link.Ref.RefClass), link.Plan, mergedPlans);
}
for (int index = 0; index < plan.Childs.Count; ++index)
{
ChildRefLoadPlan child = plan.Childs[index];
this.EnsureChildRef(this.Class.Childs.Need(child.ChildRef.ChildClass), child.Plan, mergedPlans);
}
}
internal void LoadNotAssignedProperties()
{
this.CheckNotUntypedNull();
LoadPlan plan = new LoadPlan(this.FStorage.Class);
MetadataPropertyList properties = this.Class.Properties;
DataProperty[] dataPropertyArray = this.FProperties ?? (this.FProperties = new DataProperty[properties.Count]);
for (int index = 0; index < properties.Count; ++index)
{
MetadataProperty propertyMetadata = properties[index];
if (!propertyMetadata.IsId)
{
DataProperty dataProperty = dataPropertyArray[index];
if (dataProperty == null || !dataProperty.IsAssigned)
{
plan.EnsureProperty(propertyMetadata);
}
}
}
this.Session.LoadData(plan, (DataObjectList)null, new DataId[1]
{
this.Id
}, (string)null);
}
public void EnsureProperty(MetadataProperty propertyMetadata)
{
if (propertyMetadata.IsData)
{
this.EnsureDataProperty(propertyMetadata);
}
else
{
if (!propertyMetadata.IsLink)
{
throw new DataException(string.Format("DataLoadPlan.EnsureProperty: Свойство {0}.{1}, добавляемое в план загрузки, не является простым типом или связанным объектом.", (object)this.Class.QTypeName, (object)propertyMetadata.Name));
}
LoadPlan plan = (LoadPlan)null;
for (int index = 0; index < propertyMetadata.Association.Refs.Count; ++index)
{
MetadataAssociationRef assRef = propertyMetadata.Association.Refs[index];
if (plan == null)
{
plan = new LoadPlan(assRef.RefClass);
}
this.EnsureAssociationRef(assRef, plan);
}
}
}
public Loader(LoadPlan plan) => this.RootLoader = this.EnsureObjectLoader(plan);
public override void PrepareLoadPlan(LoadPlan plan, DataSession session)
{
}
public ChildRefLoadPlan EnsureChildRef(MetadataChildRef childRef, LoadPlan plan) => this.EnsureChildRef(childRef, plan, new LoadPlan.MergedPlans());
public AssociationRefLoadPlan EnsureAssociationRef(
MetadataAssociationRef assRef,
LoadPlan plan)
{
return(this.EnsureAssociationRef(assRef, plan, new LoadPlan.MergedPlans()));
}
public AssociationRefLoadPlan(MetadataAssociationRef assRef, LoadPlan plan)
{
this.Ref = assRef;
this.Plan = LoadPlan.UseExistingOrCreateNew(plan, assRef.RefClass);
}
public ChildRefLoadPlan(MetadataChildRef childRef, LoadPlan plan)
{
this.ChildRef = childRef;
this.Plan = LoadPlan.UseExistingOrCreateNew(plan, childRef.ChildClass);
}
public void Add(LoadPlan dst, LoadPlan src)
{
this.DstPlans.Add((object)dst);
this.SrcPlans.Add((object)src);
}
public abstract void GetNavigationLoadPlans(
DataSession session,
LoadPlan sourcePlan,
LoadPlanList navigationPlans);
internal void MergeWith(LoadPlan plan) => this.MergeWith(plan, new LoadPlan.MergedPlans());
internal ObjectLoader(LoadPlan basePlan) => this.BasePlan = basePlan;
public abstract void PrepareLoadPlan(LoadPlan plan, DataSession session);