/// <summary>
/// This method reads the specified object to initialize.
/// </summary>
/// <param name="pObjectToInitialize">The object to initialize.</param>
/// <param name="pParentElement">The parent element.</param>
/// <param name="pSerializationContext">The serialization context.</param>
/// <returns>The initialized object</returns>
public override object Read(object pObjectToInitialize, XElement pParentElement, IXSerializationContext pSerializationContext)
{
PropertyInfo lPropertyInfo = pObjectToInitialize as PropertyInfo;
// Look for a sub-element with the good local name.
// ReSharper disable once PossibleNullReferenceException
IEnumerable<XElement> lElements = pParentElement.Elements(lPropertyInfo.Name);
XElement lPropertyElement = lElements.FirstOrDefault();
if (lPropertyElement == null)
{
IEnumerable<XElement> lDescendants = pParentElement.Descendants(lPropertyInfo.Name);
lPropertyElement = lDescendants.FirstOrDefault();
}
if (lPropertyElement != null)
{
IXSerializationContract lSerializationContract = pSerializationContext.SelectContract(lPropertyElement, lPropertyInfo.PropertyType);
if (lSerializationContract != null)
{
object lReadObject = lSerializationContract.Read(lPropertyInfo.GetValue(pSerializationContext.CurrentObject, null), lPropertyElement, pSerializationContext);
return pObjectToInitialize;
}
}
return null;
}
/// <summary>
/// This method reads the specified object to initialize.
/// </summary>
/// <param name="pObjectToInitialize">The object to initialize.</param>
/// <param name="pParentElement">The parent element.</param>
/// <param name="pSerializationContext">The serialization context.</param>
/// <returns>The initialized object</returns>
public override object Read(object pObjectToInitialize, XElement pParentElement, IXSerializationContext pSerializationContext)
{
PropertyInfo lPropertyInfo = pObjectToInitialize as PropertyInfo;
// Look for a sub-element with the good local name.
// ReSharper disable once PossibleNullReferenceException
IEnumerable <XElement> lElements = pParentElement.Elements(lPropertyInfo.Name);
XElement lPropertyElement = lElements.FirstOrDefault();
if (lPropertyElement == null)
{
IEnumerable <XElement> lDescendants = pParentElement.Descendants(lPropertyInfo.Name);
lPropertyElement = lDescendants.FirstOrDefault();
}
if (lPropertyElement != null)
{
IXSerializationContract lSerializationContract = pSerializationContext.SelectContract(lPropertyElement, lPropertyInfo.PropertyType);
if (lSerializationContract != null)
{
object lReadObject = lSerializationContract.Read(lPropertyInfo.GetValue(pSerializationContext.CurrentObject, null), lPropertyElement, pSerializationContext);
return(pObjectToInitialize);
}
}
return(null);
}
/// <summary>
/// THis method serializes the object in to an XElement.
/// </summary>
/// <param name="pObject">The object to serialize.</param>
/// <param name="pParentElement"></param>
/// <param name="pSerializationContext">The context of serialization</param>
/// <returns>
/// The modified XElement.
/// </returns>
public XElement Write(object pObject, XElement pParentElement, IXSerializationContext pSerializationContext)
{
pParentElement.Add(pSerializationContext.ReferenceType(pObject.GetType()));
IXSerializationContract lKeyContract = pSerializationContext.SelectContract(null, null, pObject.GetPropertyType("Key"), null);
if (lKeyContract != null)
{
XElement lKeyElement = new XElement(XConstants.KEY_TAG);
lKeyContract.Write(pObject.GetPropertyValue("Key"), lKeyElement, pSerializationContext);
pParentElement.Add(lKeyElement);
}
IXSerializationContract lValueContract = pSerializationContext.SelectContract(null, null, pObject.GetPropertyType("Value"), null);
if (lValueContract != null)
{
XElement lValueElement = new XElement(XConstants.VALUE_TAG);
lValueContract.Write(pObject.GetPropertyValue("Value"), lValueElement, pSerializationContext);
pParentElement.Add(lValueElement);
}
return(pParentElement);
}
/// <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 serializes the object in to an XElement.
/// </summary>
/// <param name="pObject">The object to serialize.</param>
/// <param name="pParentElement"></param>
/// <param name="pSerializationContext">The context of serialization</param>
/// <returns>
/// The modified XElement.
/// </returns>
public XElement Write(object pObject, XElement pParentElement, IXSerializationContext pSerializationContext)
{
pParentElement.Add(pSerializationContext.ReferenceType(pObject.GetType()));
for (int lGenericIndex = 0; lGenericIndex < pObject.GetType().GetGenericArguments().Count(); lGenericIndex++)
{
string lItemName = XConstants.TUPLE_ITEM_TAG + (lGenericIndex + 1);
IXSerializationContract lKeyContract = pSerializationContext.SelectContract(null, null, pObject.GetPropertyType(lItemName), null);
if (lKeyContract != null)
{
XElement lKeyElement = new XElement(lItemName);
lKeyContract.Write(pObject.GetPropertyValue(lItemName), lKeyElement, pSerializationContext);
pParentElement.Add(lKeyElement);
}
}
return(pParentElement);
}
/// <summary>
/// THis method serializes the object in to an XElement.
/// </summary>
/// <param name="pObject">The object to serialize.</param>
/// <param name="pParentElement">The parent element</param>
/// <param name="pSerializationContext">The context of serialization</param>
/// <returns>
/// The modified XElement.
/// </returns>
public XElement Write(object pObject, XElement pParentElement, IXSerializationContext pSerializationContext)
{
if (pObject != null)
{
Type lNullableType = typeof(Nullable <>).MakeGenericType(pObject.GetType());
pParentElement.Add(pSerializationContext.ReferenceType(lNullableType));
}
XElement lValueElement = new XElement(XConstants.VALUE_TAG);
IXSerializationContract lSerializationContract = pSerializationContext.SelectContract(pParentElement, pObject);
if (lSerializationContract != null)
{
lSerializationContract.Write(pObject, lValueElement, pSerializationContext);
}
pParentElement.Add(lValueElement);
return(pParentElement);
}
/// <summary>
/// This method writes the specified object.
/// </summary>
/// <param name="pObject">The object to serialize (it is the property value of the parent object)</param>
/// <param name="pParentElement">The parent element (it is the property name of the parent object).</param>
/// <param name="pSerializationContext">The serialization context.</param>
/// <returns>The modified parent element</returns>
public virtual XElement Write(object pObject, XElement pParentElement, IXSerializationContext pSerializationContext)
{
Type lFieldType;
object lFieldObject = pSerializationContext.CurrentObject.GetFieldValue(this.TypedAttribute.FieldName, out lFieldType);
XElement lFieldElement = new XElement("Field");
lFieldElement.SetAttributeValue("fieldName", this.TypedAttribute.FieldName);
IXSerializationContract lSerializationContract = pSerializationContext.SelectContract(null, lFieldObject);
if (lSerializationContract != null)
{
lSerializationContract.Write(lFieldObject, lFieldElement, pSerializationContext);
}
pParentElement.Add(lFieldElement);
this.Attribute = null;
return(pParentElement);
}
/// <summary>
/// This method reads the specified element.
/// </summary>
/// <param name="pObjectToInitialize">The object to initialize (it is the property value of the parent object)</param>
/// <param name="pParentElement">The parent element (it is the property name of the parent object).</param>
/// <param name="pSerializationContext">The serialization context.</param>
/// <returns>The initialized object if the input object is valid.</returns>
public virtual object Read(object pObjectToInitialize, XElement pParentElement, IXSerializationContext pSerializationContext)
{
PropertyInfo lPropertyInfo = pObjectToInitialize as PropertyInfo;
if (lPropertyInfo != null && pSerializationContext.CurrentObject != null)
{
if (pParentElement.Elements(lPropertyInfo.Name).Elements("Field").Any())
{
XElement lFieldElement = pParentElement.Elements(lPropertyInfo.Name).Elements("Field").FirstOrDefault(pElement => pElement.Attribute("fieldName") != null && pElement.Attribute("fieldName").Value == this.TypedAttribute.FieldName);
Type lFieldType;
object lFieldObject = pSerializationContext.CurrentObject.GetFieldValue(this.TypedAttribute.FieldName, out lFieldType);
IXSerializationContract lSerializationContract = pSerializationContext.SelectContract(null, lFieldType);
if (lSerializationContract != null)
{
object lReadFieldObject = lSerializationContract.Read(lFieldObject, lFieldElement, pSerializationContext);
pSerializationContext.CurrentObject.SetFieldValue(this.TypedAttribute.FieldName, lReadFieldObject);
}
// Check if a initial synchronisation method exits.
if (string.IsNullOrWhiteSpace(this.TypedAttribute.SyncFieldMethod) == false)
{
MethodInfo lSynchronizationMethod = pSerializationContext.CurrentObject.GetType().GetMethod(this.TypedAttribute.SyncFieldMethod, BindingFlags.NonPublic | BindingFlags.Instance);
if (lSynchronizationMethod != null)
{
lSynchronizationMethod.Invoke(pSerializationContext.CurrentObject, null);
}
}
}
else if (pParentElement.Elements(lPropertyInfo.Name).Any())
{
object lValue = new InternalReferenceSerializationContract().Read(pObjectToInitialize, pParentElement.Elements(lPropertyInfo.Name).FirstOrDefault(), pSerializationContext);
pSerializationContext.CurrentObject.SetPropertyValue(lPropertyInfo.Name, lValue);
}
}
else
{
IXmlLineInfo lInfo = pParentElement;
pSerializationContext.PushError(new XSerializationError(XErrorType.Parsing, lInfo.LineNumber, lInfo.LinePosition, pSerializationContext.CurrentFile, "Field serialization contract must be called with a property info and not null object as parameter"));
}
return(pObjectToInitialize);
}
/// <summary>
/// This method writes the specified object.
/// </summary>
/// <param name="pObject">The object to serialize.</param>
/// <param name="pParentElement">The parent element.</param>
/// <param name="pSerializationContext">The serialization context.</param>lList.GetType().GetGenericArguments()[0]
/// <returns>The modified parent element</returns>
public override XElement Write(object pObject, XElement pParentElement, IXSerializationContext pSerializationContext)
{
// Store the type.
pParentElement.Add(pSerializationContext.ReferenceType(pObject.GetType()));
// Store all items.
IList lList = pObject as IList;
foreach (object lItem in lList)
{
XElement lItemElement = new XElement(XConstants.ITEM_TAG);
IXSerializationContract lContract = pSerializationContext.SelectContract(lItemElement, lItem);
if (lContract != null)
{
lContract.Write(lItem, lItemElement, pSerializationContext);
}
pParentElement.Add(lItemElement);
}
return(pParentElement);
}
/// <summary>
/// This method writes the specified object.
/// </summary>
/// <param name="pObject">The object to serialize.</param>
/// <param name="pParentElement">The parent element.</param>
/// <param name="pSerializationContext">The serialization context.</param>
/// <returns>The modified parent element</returns>
public override System.Xml.Linq.XElement Write(object pObject, System.Xml.Linq.XElement pParentElement, IXSerializationContext pSerializationContext)
{
IXTemplate lTemplate = pObject as IXTemplate;
if (lTemplate != null)
{
// Creating the templated object.
object lTemplatedObject = lTemplate.Create();
if (lTemplatedObject != null)
{
IXSerializationContract lContract = pSerializationContext.SelectContract(null, lTemplatedObject);
if (lContract != null)
{
lContract.Write(lTemplatedObject, pParentElement, pSerializationContext);
}
}
}
return(pParentElement);
}
/// <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);
}
/// <summary>
/// Writes the specified object.
/// </summary>
/// <param name="pObject">The object.</param>
/// <param name="pParentElement">The parent element.</param>
/// <param name="pSerializationContext">The serialization context.</param>
/// <returns></returns>
public override XElement Write(object pObject, XElement pParentElement, IXSerializationContext pSerializationContext)
{
pParentElement.Add(pSerializationContext.ReferenceType(pObject.GetType()));
// Get public propertyinfo and the private one bearing a XSerializationAttribute attribute.
PropertyInfo[] lPublicPropertyInfos = pObject.GetType().GetProperties();
PropertyInfo[] lNonPublicPropertyInfos = pObject.GetType().GetProperties(BindingFlags.Instance | BindingFlags.NonPublic);
PropertyInfo[] lFilteredPropertyInfos = lPublicPropertyInfos.Union(lNonPublicPropertyInfos.Where(pElt => pElt.GetCustomAttributes(typeof(IXSerializationAttribute), true).Any())).ToArray();
PropertyInfo[] lSortedFilteredPropertyInfos = lFilteredPropertyInfos.Select(pX => new { Property = pX, Attribute = (OrderXSerializationAttribute)Attribute.GetCustomAttribute(pX, typeof(OrderXSerializationAttribute), true) }).OrderBy(pX => pX.Attribute != null ? pX.Attribute.Order : Int32.MaxValue).ThenBy(pX => pX.Property.Name).Select(pX => pX.Property).ToArray();
pParentElement.SetAttributeValue(XConstants.ID_ATTRIBUTE, pSerializationContext.GetObjectReference(pObject));
foreach (PropertyInfo lPropertyInfo in lSortedFilteredPropertyInfos)
{
IXSerializationContract lSerializationContract = pSerializationContext.SelectContract(null, lPropertyInfo);
if (lSerializationContract != null)
{
lSerializationContract.Write(lPropertyInfo, pParentElement, pSerializationContext);
}
}
return(pParentElement);
}
/// <summary>
/// This method reads the specified element.
/// </summary>
/// <param name="pObjectToInitialize">The object to initialize</param>
/// <param name="pParentElement">The parent element.</param>
/// <param name="pSerializationContext">The serialization context.</param>
/// <returns>The initialized object if the input object is valid.</returns>
public override object Read(object pObjectToInitialize, XElement pParentElement, IXSerializationContext pSerializationContext)
{
if
(pObjectToInitialize != null)
{
IList lList = pObjectToInitialize as IList;
if
(lList != null)
{
foreach
(XElement lChild in pParentElement.Elements(XConstants.ITEM_TAG))
{
Type[] lInterfaces = lList.GetType().GetInterfaces();
Type lGenericListType = lInterfaces.FirstOrDefault(pType => pType.IsGenericType == true &&
pType.GetGenericTypeDefinition() == typeof(IList <>));
Type lItemType = lGenericListType.GetGenericArguments()[0];
XElement lItemTypeElement = lChild.Element(XConstants.TYPE_TAG);
if
(lItemTypeElement != null)
{
lItemType = pSerializationContext.ResolveType(lItemTypeElement);
}
IXSerializationContract lContract = pSerializationContext.SelectContract(lChild, lItemType);
if
(lContract != null)
{
object lItem = null;
lItem = lContract.Read(lItem, lChild, pSerializationContext);
lList.Add(lItem);
}
}
}
}
return(pObjectToInitialize);
}
/// <summary>
/// THis method deserialized an X element in to an object.
/// </summary>
/// <param name="pObjectToInitialize"></param>
/// <param name="pParentElement">The parent element to convert.</param>
/// <param name="pSerializationContext">The context of serialization</param>
/// <returns>The initialized object</returns>
public object Read(object pObjectToInitialize, XElement pParentElement, IXSerializationContext pSerializationContext)
{
XElement lTypeElement = pParentElement.Element(XConstants.TYPE_TAG);
XElement lValueElement = pParentElement.Element(XConstants.VALUE_TAG);
if (lTypeElement != null && lValueElement != null)
{
Type lRetrievedType = pSerializationContext.ResolveType(lTypeElement);
if (lRetrievedType != null)
{
IXSerializationContract lSerializationContract = pSerializationContext.SelectContract(lValueElement, lRetrievedType.GetGenericArguments()[0]);
if (lSerializationContract != null)
{
Type lValueType = lRetrievedType.GetGenericArguments()[0];
object lValue = lValueType.DefaultValue();
lValue = lSerializationContract.Read(lValue, lValueElement, pSerializationContext);
return(Activator.CreateInstance(lRetrievedType, lValue));
}
}
}
return(null);
}
/// <summary>
/// THis method serializes the object in to an XElement.
/// </summary>
/// <param name="pObject">The object to serialize.</param>
/// <param name="pParentElement">The parent element</param>
/// <param name="pSerializationContext">The context of serialization</param>
/// <returns>
/// The modified XElement.
/// </returns>
public XElement Write(object pObject, XElement pParentElement, IXSerializationContext pSerializationContext)
{
if (pObject != null)
{
Type lNullableType = typeof(Nullable<>).MakeGenericType(pObject.GetType());
pParentElement.Add(pSerializationContext.ReferenceType(lNullableType));
}
XElement lValueElement = new XElement(XConstants.VALUE_TAG);
IXSerializationContract lSerializationContract = pSerializationContext.SelectContract(pParentElement, pObject);
if (lSerializationContract != null)
{
lSerializationContract.Write(pObject, lValueElement, pSerializationContext);
}
pParentElement.Add(lValueElement);
return pParentElement;
}
/// <summary>
/// THis method deserialized an X element in to an object.
/// </summary>
/// <param name="pObjectToInitialize"></param>
/// <param name="pParentElement">The parent element to convert.</param>
/// <param name="pSerializationContext">The context of serialization</param>
/// <returns>The initialized object</returns>
public object Read(object pObjectToInitialize, XElement pParentElement, IXSerializationContext pSerializationContext)
{
XElement lTypeElement = pParentElement.Element(XConstants.TYPE_TAG);
XElement lValueElement = pParentElement.Element(XConstants.VALUE_TAG);
if (lTypeElement != null && lValueElement != null)
{
Type lRetrievedType = pSerializationContext.ResolveType(lTypeElement);
if (lRetrievedType != null)
{
IXSerializationContract lSerializationContract = pSerializationContext.SelectContract(lValueElement, lRetrievedType.GetGenericArguments()[0]);
if (lSerializationContract != null)
{
Type lValueType = lRetrievedType.GetGenericArguments()[0];
object lValue = lValueType.DefaultValue();
lValue = lSerializationContract.Read(lValue, lValueElement, pSerializationContext);
return Activator.CreateInstance(lRetrievedType, lValue);
}
}
}
return null;
}
/// <summary>
/// THis method serializes the object in to an XElement.
/// </summary>
/// <param name="pObject">The object to serialize.</param>
/// <param name="pParentElement"></param>
/// <param name="pSerializationContext">The context of serialization</param>
/// <returns>
/// The modified XElement.
/// </returns>
public XElement Write(object pObject, XElement pParentElement, IXSerializationContext pSerializationContext)
{
pParentElement.Add(pSerializationContext.ReferenceType(pObject.GetType()));
for (int lGenericIndex = 0; lGenericIndex < pObject.GetType().GetGenericArguments().Count(); lGenericIndex++)
{
string lItemName = XConstants.ITEM_TAG + (lGenericIndex + 1);
IXSerializationContract lKeyContract = pSerializationContext.SelectContract(null, null, pObject.GetPropertyType(lItemName), null);
if (lKeyContract != null)
{
XElement lKeyElement = new XElement(lItemName);
lKeyContract.Write(pObject.GetPropertyValue(lItemName), lKeyElement, pSerializationContext);
pParentElement.Add(lKeyElement);
}
}
return pParentElement;
}
/// <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>
/// THis method serializes the object in to an XElement.
/// </summary>
/// <param name="pObject">The object to serialize.</param>
/// <param name="pParentElement"></param>
/// <param name="pSerializationContext">The context of serialization</param>
/// <returns>
/// The modified XElement.
/// </returns>
public XElement Write(object pObject, XElement pParentElement, IXSerializationContext pSerializationContext)
{
pParentElement.Add(pSerializationContext.ReferenceType(pObject.GetType()));
IXSerializationContract lKeyContract = pSerializationContext.SelectContract(null, null, pObject.GetPropertyType("Key"), null);
if (lKeyContract != null)
{
XElement lKeyElement = new XElement(XConstants.KEY_TAG);
lKeyContract.Write(pObject.GetPropertyValue("Key"), lKeyElement, pSerializationContext);
pParentElement.Add(lKeyElement);
}
IXSerializationContract lValueContract = pSerializationContext.SelectContract(null, null, pObject.GetPropertyType("Value"), null);
if (lValueContract != null)
{
XElement lValueElement = new XElement(XConstants.VALUE_TAG);
lValueContract.Write(pObject.GetPropertyValue("Value"), lValueElement, pSerializationContext);
pParentElement.Add(lValueElement);
}
return pParentElement;
}
/// <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.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;
}
