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