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