protected void AddTyp(CTyp aTyp)
{
if (!this.TypsM.IsNullRef())
{
throw new InvalidOperationException();
}
{
var aProperties0 = aTyp.Properties.OfType <CSkalarRefMetaInfo>();
var aProperties1 = from aTest in aProperties0
where aTest.IsDefined <CTargetTypeAttribute>()
select new Tuple <CSkalarRefMetaInfo, CTargetTypeAttribute>(aTest, aTest.GetAttribute <CTargetTypeAttribute>())
;
var aProperties2 = from aTest in aProperties1
where aTest.Item2.TargetType.IsDefined(typeof(CSaveConverterAttribute), true)
select new Tuple <CSkalarRefMetaInfo, CTargetTypeAttribute, CSaveConverterAttribute>
(aTest.Item1, aTest.Item2, aTest.Item2.TargetType.GetCustomAttribute <CSaveConverterAttribute>(true))
;
var aProperties = aProperties2;
foreach (var aProperty in aProperties)
{
var aTargetTypeAttribute = aProperty.Item2;
var aSaveConverterAtttribute = aProperty.Item3;
var aSaveConverter = (CConverter)Activator.CreateInstance(aSaveConverterAtttribute.ConverterType);
this.ModelConverterChain.Ly1WrapConverters.Register(aTargetTypeAttribute.TargetType, aSaveConverter);
}
}
this.TypList.Add(aTyp);
}
private bool CalcIsPersistent(CRefMetaInfo aProperty, CTyp aObjectTyp)
{
var aIsPersistent = this.GetDeclaringTyp(aProperty) == aObjectTyp ||
this.CalcSpreadAcrossTables(aProperty)
;
return(aIsPersistent);
}
private FileInfo GetObjectFileInfo(CTyp aType, Guid aGuid)
{
var aExtension = this.GetExtension(aType);
var aDirectory = this.GetObjectDirectory(aType);
var aFileInfo = new FileInfo(Path.Combine(aDirectory.FullName, aGuid.ToString() + aExtension));
return(aFileInfo);
}
public override IEnumerable <CObject> LoadObjects(CTyp aType)
{
var aObjectStorage = this;
var aDirectory = this.GetObjectDirectory(aType);
var aFiles = aDirectory.GetFiles();
var aObjects = from aFile in aFiles select this.LoadObject(aType, aFile);
return(aObjects);
}
private IEnumerable <CRefMetaInfo> CalcPersistentProperties(CTyp aObjectTyp)
{
var aHirarchy = this.CalcHirarchy(aObjectTyp);
var aProperties = from aApsect in aHirarchy
from aProperty in this.CalcPersistentProperties(aObjectTyp, aApsect)
select aProperty;
return(aProperties);
}
private string GetExtension(CTyp aTyp)
{
var aIsBlop = aTyp.SystemType.Equals(typeof(CBlop));
var aExtension = aIsBlop
? ".bin"
: ".xml"
;
return(aExtension);
}
private IEnumerable <CRefMetaInfo> CalcPersistentProperties(CTyp aObjectTyp, CTyp aAspect)
{
var aProperties1 = aAspect.Properties;
var aProperties2 = from aProperty in aProperties1
where this.CalcIsPersistent(aProperty, aObjectTyp)
select aProperty
;
return(aProperties2);
}
private CTyp CalcBaseTypNullable(CTyp aTyp)
{
var aSystemType = aTyp.SystemType;
var aBaseSystemType = aSystemType.BaseType;
var aSchema = this;
var aBaseType = aSchema.Typs.ContainsKey(aBaseSystemType)
? aSchema.Typs.GetBySystemType(aBaseSystemType)
: default(CTyp)
;
return(aBaseType);
}
private IEnumerable <CTyp> CalcHirarchy(CTyp aTyp)
{
var aBaseTyp = this.CalcBaseTypNullable(aTyp);
if (!aBaseTyp.IsNullRef())
{
foreach (var aSubTyp in this.CalcHirarchy(aBaseTyp))
{
yield return(aSubTyp);
}
}
yield return(aTyp);
}
internal CObject LoadObject(CTyp aType, FileInfo aFileInfo)
{
var aObjectId = this.GetGuidFromFileName(aFileInfo);
return(this.LoadOnDemand(aObjectId,
() =>
{
var aObject = aType.NewObject(this);
aObject.GuidValue = aObjectId;
aObject.Load();
return aObject;
}
));
}
protected override void Save(CEntityObject aEntityObject, CTyp aAspect)
{
var aFileInfo = this.GetObjectFileInfo(aAspect, aEntityObject.Guid.Value);
if (aEntityObject.IsLocallyDeleted)
{
aFileInfo.Delete();
}
else
{
var aPersistentProperties = this.Schema.GetPersistentProperties(aAspect);
var aXmlDocument = aEntityObject.NewXmlDocument(aPersistentProperties);
aXmlDocument.Save(aFileInfo.FullName);
}
}
protected override void Load(CEntityObject aEntityObject, CTyp aAspect)
{
var aStorage = this;
var aObjectId = aEntityObject.Guid.Value;
var aFileInfo = this.GetObjectFileInfo(aAspect, aObjectId);
var aXmlDocument = new XmlDocument();
var aSchema = aStorage.Schema;
var aProperties = aSchema.GetPersistentProperties(aAspect);
aXmlDocument.Load(aFileInfo.FullName);
var aXmlElement = aXmlDocument.SelectNodes(CRefMetaInfo.ObjectElementName).OfType <XmlElement>().Single();
foreach (var aProperty in aProperties)
{
aProperty.LoadXml(aEntityObject, aXmlElement);
}
}
public static object Test000()
{
using (DClsszDataContext context = new DClsszDataContext())
{
DbRoot root = Queryable.First <DbRoot>(context.DbRoots);
for (int i = 0; i < root.CTyps.Count; i++)
{
CTyp typ = Enumerable.First <CTyp>(Enumerable.Skip <CTyp>(root.CTyps, i));
for (int j = 0; j < typ.FTyps.Count; j++)
{
FTyp typ2 = Enumerable.First <FTyp>(Enumerable.Skip <FTyp>(typ.FTyps, j));
for (int k = 0; k < typ2.Itms.Count; k++)
{
Itm itm = Enumerable.First <Itm>(Enumerable.Skip <Itm>(typ2.Itms, k));
for (int m = 0; m < itm.Parts.Count; m++)
{
Enumerable.First <Part>(Enumerable.Skip <Part>(itm.Parts, m));
}
}
}
}
}
return(null);
}
internal IEnumerable <CTyp> GetHirarchy(CTyp aTyp) => this.CalcHirarchy(aTyp); //// TODO-Opt
protected abstract void Load(CEntityObject aEntityObject, CTyp aAspect);
public override IEnumerable <CObject> LoadObjects(CTyp aType)
=> new CObject[]
{
};
internal IEnumerable <CRefMetaInfo> GetPersistentProperties(CTyp aTyp) => this.PersistentProperties[aTyp];
public abstract CObject LoadObject(CTyp aType, Guid aGuid);
protected override void Save(CEntityObject aEntityObject, CTyp aAspect) => throw new InvalidOperationException();
public override CObject LoadObject(CTyp aType, Guid aGuid) => throw new InvalidOperationException();
public override CObject LoadObject(CTyp aType, Guid aGuid)
{
return(this.LoadObject(aType, this.GetObjectFileInfo(aType, aGuid)));
}
public abstract IEnumerable <CObject> LoadObjects(CTyp aType);
internal DirectoryInfo GetObjectDirectory(CTyp aType)
{
return(this.GetObjectDirectory(aType.TableName));
}
protected abstract void Save(CEntityObject aEntityObject, CTyp aAspect);
