/// <summary> /// This method creates the specified element. /// </summary> /// <param name="pParentElement">The element.</param> /// <param name="pSerializationContext">The serialization context.</param> /// <returns> /// The created object. /// </returns> public object Create(XElement pParentElement, IXSerializationContext pSerializationContext) { XElement lTypeElement = pParentElement.Element(XConstants.TYPE_TAG); if (lTypeElement != null) { Type lRetrievedType = pSerializationContext.ResolveType(lTypeElement); if (lRetrievedType != null) { XElement lKeyElement = pParentElement.Descendants(XConstants.KEY_TAG).FirstOrDefault(); IXSerializationContract lKeyContract = pSerializationContext.SelectContract(lKeyElement, null, lRetrievedType.GetGenericArguments()[0], null); object lKeyObject = null; if (lKeyContract.NeedCreate) { lKeyObject = lKeyContract.Create(lKeyElement, pSerializationContext); } else { try { lKeyObject = Activator.CreateInstance(lRetrievedType.GetGenericArguments()[0], true); } catch { } } lKeyObject = lKeyContract.Read(lKeyObject, lKeyElement, pSerializationContext); XElement lValueElement = pParentElement.Descendants(XConstants.VALUE_TAG).FirstOrDefault(); IXSerializationContract lValueContract = pSerializationContext.SelectContract(lValueElement, null, lRetrievedType.GetGenericArguments()[1], null); object lValueObject = null; if (lValueContract.NeedCreate) { lValueObject = lValueContract.Create(lValueElement, pSerializationContext); } else { try { lValueObject = Activator.CreateInstance(lRetrievedType.GetGenericArguments()[1], true); } catch { } } lValueObject = lValueContract.Read(lValueObject, lValueElement, pSerializationContext); return(Activator.CreateInstance(lRetrievedType, new object[] { lKeyObject, lValueObject })); } } return(null); }
/// <summary> /// Attempt to retrieve the missing reference (last chance) /// </summary> /// <param name="pObjectToInitialize">The object to initialize</param> /// <param name="pParentElement"></param> /// <param name="pReference">The reference to look for.</param> /// <param name="pSerializationContext">The serialization context.</param> /// <returns>The extracted object, null otherwise.</returns> private object AttemptReferenceRetrieval(object pObjectToInitialize, XElement pParentElement, int pReference, IXSerializationContext pSerializationContext) { object lResult = null; XElement lXRoot = this.GetRoot(pParentElement); if (lXRoot != null) { IEnumerable <XElement> lXElements = lXRoot.Descendants(pParentElement.Name); if (lXElements != null && lXElements.Any()) { foreach (XElement lXElement in lXElements) { XAttribute lXId = lXElement.Attribute(XConstants.ID_ATTRIBUTE); if (lXId != null) { int lId = Convert.ToInt32(lXId.Value.Trim(), CultureInfo.InvariantCulture); if (lId == pReference) { XElement lXType = lXElement.Element(XConstants.TYPE_TAG); if (lXType != null) { Type lType = pSerializationContext.ResolveType(lXType); IXSerializationContract lContract = pSerializationContext.SelectContract(lXElement, null, lType, pObjectToInitialize); if (lContract != null) { if (lContract.NeedCreate) { pObjectToInitialize = lContract.Create(lXElement, pSerializationContext); } lResult = lContract.Read(pObjectToInitialize, lXElement, pSerializationContext); if (lResult != null) { pSerializationContext.PushObject(lResult, pReference); // Cache it into ref by obj caches. pSerializationContext.PopObject(); // But remove it from current object stack then to come back to previous current objects stack state. } } } break; } } } } } return(lResult); }
/// <summary> /// This method deserializes a XElement into an object. /// </summary> /// <param name="pElement">The element to deserialize.</param> /// <returns>The created object, null if the deserialization failed.</returns> public virtual object Deserialize(XElement pElement) { this.IsWriting = false; this.mErrors.Clear(); XElement lTypeContainerElement = pElement.Element(XConstants.TYPE_CONTAINER_TAG); if (lTypeContainerElement != null) { this.ReadTypeContainer(lTypeContainerElement); } XElement lTypeElement = pElement.Element(XConstants.TYPE_TAG); if (lTypeElement != null) { IXSerializationContract lContract = this.SelectContract(pElement, this.ResolveType(lTypeElement)); if (lContract != null) { if (this.mCurrentDirectory == null) { this.mCurrentDirectory = new DirectoryInfo(Environment.CurrentDirectory); } object lObject = null; SerializationContractDecorator lDecoratorContract = lContract as SerializationContractDecorator; if (lDecoratorContract != null && lDecoratorContract.NeedCreate) { // The decorator read method will handle the object creation. lObject = lContract.Read(lObject, pElement, this); } else { // Forcing the object creation. lObject = lContract.Create(pElement, this); lObject = lContract.Read(lObject, pElement, this); } return(lObject); } } IXmlLineInfo lInfo = pElement; this.PushError(new XSerializationError(XErrorType.UnkwnonType, lInfo.LineNumber, lInfo.LinePosition, this.CurrentFile, string.Empty)); return(null); }
/// <summary> /// This method creates the specified element. /// </summary> /// <param name="pParentElement">The element.</param> /// <param name="pSerializationContext">The serialization context.</param> /// <returns> /// The created object. /// </returns> public object Create(XElement pParentElement, IXSerializationContext pSerializationContext) { XElement lTypeElement = pParentElement.Element(XConstants.TYPE_TAG); if (lTypeElement != null) { Type lRetrievedType = pSerializationContext.ResolveType(lTypeElement); if (lRetrievedType != null) { List <object> lParameters = new List <object>(); for (int lGenericIndex = 0; lGenericIndex < lRetrievedType.GetGenericArguments().Count(); lGenericIndex++) { string lItemName = XConstants.TUPLE_ITEM_TAG + (lGenericIndex + 1); XElement lItemElement = pParentElement.Descendants(lItemName).FirstOrDefault(); IXSerializationContract lItemContract = pSerializationContext.SelectContract(lItemElement, null, lRetrievedType.GetGenericArguments()[lGenericIndex], null); object lItemObject = null; if (lItemContract.NeedCreate) { lItemObject = lItemContract.Create(lItemElement, pSerializationContext); } else { try { lItemObject = Activator.CreateInstance(lRetrievedType.GetGenericArguments()[lGenericIndex], true); } catch { } } lItemObject = lItemContract.Read(lItemObject, lItemElement, pSerializationContext); lParameters.Add(lItemObject); } return(Activator.CreateInstance(lRetrievedType, lParameters.ToArray())); } } return(null); }