/// <summary>
/// Deserializers an object from the given <see cref="reader"/>
/// </summary>
/// <param name="instance">An existing instance to populate</param>
/// <param name="parameters">The paramters for deserialization</param>
/// <param name="reader">The reader<see cref="XmlReader"/> to deserialize from</param>
/// <returns>The deserialized object</returns>
public virtual T Deserialize(T instance, XmlReader reader, SerializationParameters parameters)
{
var state = new SerializationContext(this.Options, parameters);
reader.Read();
XmlReaderHelper.ReadUntilTypeReached(reader, XmlNodeType.Element);
if (reader.NodeType != XmlNodeType.Element)
{
throw new XmlSerializerException("Can't find root XML node.");
}
var reval = (T)((ComplexTypeTypeSerializer)rootMemberInfo.GetSerializer(reader)).Deserialize(instance, reader, state);
return(reval);
}
protected virtual void DeserializeElement(object obj, XmlReader reader, SerializationContext state)
{
SerializationMemberInfo serializationMember;
if (reader.Prefix.Length > 0)
{
serializationMember = (SerializationMemberInfo)elementMembersMap[state.Parameters.Namespaces.GetNamespace(reader.Prefix) + (char)0xff + reader.LocalName];
}
else
{
serializationMember = (SerializationMemberInfo)elementMembersMap[reader.LocalName];
}
if (serializationMember == null)
{
XmlReaderHelper.ReadAndConsumeMatchingEndElement(reader);
}
else
{
state.PushCurrentMemberInfo(serializationMember);
try
{
if (serializationMember.SerializeAsValueNodeAttributeName != null &&
serializationMember.GetSerializer(reader) is TypeSerializerWithSimpleTextSupport)
{
var s = reader.GetAttribute(serializationMember.SerializeAsValueNodeAttributeName);
var serializer = serializationMember.GetSerializer(reader);
serializationMember.SetValue(obj, ((TypeSerializerWithSimpleTextSupport)(serializer)).Deserialize(s, state));
XmlReaderHelper.ReadAndConsumeMatchingEndElement(reader);
}
else
{
serializationMember.SetValue(obj, serializationMember.GetSerializer(reader).Deserialize(reader, state));
}
}
finally
{
state.PopCurrentMemberInfo();
}
}
}
public virtual object Deserialize(object instance, XmlReader reader, SerializationContext state)
{
var obj = instance;
state.DeserializationStart(obj);
if (reader.AttributeCount > 0)
{
for (var i = 0; i < reader.AttributeCount; i++)
{
reader.MoveToAttribute(i);
DeserializeAttribute(obj, reader, state);
}
reader.MoveToElement();
}
// If there's no subelements then exit
if (reader.IsEmptyElement)
{
reader.ReadStartElement();
return(obj);
}
reader.ReadStartElement();
// Read elements
while (true)
{
XmlReaderHelper.ReadUntilAnyTypesReached(reader, new XmlNodeType[] { XmlNodeType.Element, XmlNodeType.EndElement, XmlNodeType.Text, XmlNodeType.CDATA });
if (reader.NodeType == XmlNodeType.Element)
{
DeserializeElement(obj, reader, state);
//XmlReaderHelper.ReadAndConsumeMatchingEndElement(reader);
}
else if (reader.NodeType == XmlNodeType.Text || reader.NodeType == XmlNodeType.CDATA)
{
if (reader.HasValue)
{
DeserializeText(obj, reader, state);
reader.Read();
}
}
else
{
if (reader.NodeType == XmlNodeType.EndElement)
{
reader.ReadEndElement();
}
else
{
// Unknown element
}
break;
}
}
state.DeserializationEnd(obj);
return(obj);
}
/// <summary>
///
/// </summary>
/// <param name="reader"></param>
/// <param name="state"></param>
/// <returns></returns>
public override object Deserialize(XmlReader reader, SerializationState state)
{
object retval;
LightSerializationMember serializationMember;
ISerializationUnhandledMarkupListener uhm;
retval = Activator.CreateInstance(m_Type);
state.DeserializationStart(retval);
uhm = retval as ISerializationUnhandledMarkupListener;
if (reader.AttributeCount > 0)
{
for (int i = 0; i < reader.AttributeCount; i++)
{
reader.MoveToAttribute(i);
serializationMember = (LightSerializationMember)m_AttributeMembersMap[reader.Name];
if (serializationMember == null)
{
// Unknown attribute.
if (uhm != null)
{
uhm.UnhandledAttribute(reader.Name, reader.Value);
}
}
else
{
serializationMember.SetValue(retval, serializationMember.Serializer.Deserialize(reader, state));
}
}
reader.MoveToElement();
}
if (reader.IsEmptyElement)
{
reader.ReadStartElement();
return(retval);
}
reader.ReadStartElement();
// Read elements
while (true)
{
XmlReaderHelper.ReadUntilAnyTypesReached(reader,
new XmlNodeType[] { XmlNodeType.Element, XmlNodeType.EndElement });
if (reader.NodeType == XmlNodeType.Element)
{
serializationMember = (LightSerializationMember)m_ElementMembersMap[reader.Name];
if (serializationMember == null)
{
// Unknown element.
}
else
{
serializationMember.SetValue(retval, serializationMember.Serializer.Deserialize(reader, state));
}
}
else
{
if (reader.NodeType == XmlNodeType.EndElement)
{
reader.ReadEndElement();
}
else
{
if (uhm != null)
{
uhm.UnhandledOther(reader.ReadOuterXml());
}
}
break;
}
}
state.DeserializationEnd(retval);
return(retval);
}
/// <summary>
///
/// </summary>
/// <param name="reader"></param>
/// <param name="state"></param>
/// <returns></returns>
public override object Deserialize(XmlReader reader, SerializationState state)
{
IList retval = null;
if (m_ListType.IsArray)
{
retval = new ArrayList();
}
else
{
retval = (IList)Activator.CreateInstance(m_ListType);
state.DeserializationStart(retval);
}
// Go thru all elements and deserialize each one.
if (reader.IsEmptyElement)
{
reader.ReadStartElement();
}
else
{
reader.ReadStartElement();
for (;;)
{
ListItem listItem;
XmlReaderHelper.ReadUntilAnyTypesReached(reader, XmlReaderHelper.ElementOrEndElement);
if (reader.NodeType == XmlNodeType.Element)
{
listItem = (ListItem)m_AliasToItemMap[reader.Name];
if (listItem.Attribute != null &&
listItem.Attribute.SerializeAsValueNode &&
listItem.Attribute.ValueNodeAttributeName != null &&
listItem.Serializer is TypeSerializerWithSimpleTextSupport)
{
string s;
s = reader.GetAttribute(listItem.Attribute.ValueNodeAttributeName);
retval.Add(((TypeSerializerWithSimpleTextSupport)listItem.Serializer).Deserialize(s, state));
XmlReaderHelper.ReadAndConsumeMatchingEndElement(reader);
}
else
{
retval.Add(listItem.Serializer.Deserialize(reader, state));
}
}
else
{
if (reader.NodeType == XmlNodeType.EndElement)
{
reader.ReadEndElement();
}
break;
}
}
}
if (m_ListType.IsArray)
{
Array array = Array.CreateInstance(m_ListType.GetElementType(), retval.Count);
state.DeserializationStart(retval);
retval.CopyTo(array, 0);
retval = array;
}
state.DeserializationEnd(retval);
return(retval);
}
protected override void DeserializeElement(object obj, XmlReader reader, SerializationContext state)
{
ListItem listItem;
bool isGenericList;
MethodInfo methodInfo;
System.Collections.IList list;
if (obj is System.Collections.IList)
{
methodInfo = null;
isGenericList = false;
list = (System.Collections.IList)obj;
}
else
{
list = null;
isGenericList = true;
methodInfo = obj.GetType().GetMethod("Add");
}
if (base.CanDeserializeElement(obj, reader, state))
{
base.DeserializeElement (obj, reader, state);
return;
}
if (aliasToItemMap.TryGetValue(reader.Name, out listItem))
{
if (listItem.Attribute != null
&& listItem.Attribute.SerializeAsValueNode
&& listItem.Attribute.ValueNodeAttributeName != null
&& listItem.Serializer is TypeSerializerWithSimpleTextSupport)
{
var s = reader.GetAttribute(listItem.Attribute.ValueNodeAttributeName);
if (isGenericList)
{
methodInfo.Invoke(obj, new object[] { ((TypeSerializerWithSimpleTextSupport)listItem.Serializer).Deserialize(s, state) });
}
else
{
list.Add(((TypeSerializerWithSimpleTextSupport)listItem.Serializer).Deserialize(s, state));
}
XmlReaderHelper.ReadAndConsumeMatchingEndElement(reader);
}
else
{
if (isGenericList)
{
methodInfo.Invoke(obj, new object[] { listItem.Serializer.Deserialize(reader, state) });
}
else
{
list.Add(listItem.Serializer.Deserialize(reader, state));
}
}
}
else
{
TypeSerializer serializer = null;
if (this.dynamicTypeResolver != null)
{
var type = dynamicTypeResolver.GetType(reader);
if (type != null)
{
serializer = cache.GetTypeSerializerBySupportedType(type);
}
}
if (serializer == null)
{
base.DeserializeElement (obj, reader, state);
}
else
{
if (isGenericList)
{
methodInfo.Invoke(obj, new object[] { serializer.Deserialize(reader, state) });
}
else
{
list.Add(serializer.Deserialize(reader, state));
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="reader"></param>
/// <param name="state"></param>
/// <returns></returns>
public override object Deserialize(XmlReader reader, SerializationState state)
{
object retval;
SerializationMemberInfo serializationMember;
ISerializationUnhandledMarkupListener uhm;
retval = Activator.CreateInstance(m_Type);
state.DeserializationStart(retval);
uhm = retval as ISerializationUnhandledMarkupListener;
if (reader.AttributeCount > 0)
{
for (int i = 0; i < reader.AttributeCount; i++)
{
reader.MoveToAttribute(i);
if (reader.Prefix == "xmlns")
{
continue;
}
if (reader.Prefix.Length > 0)
{
serializationMember = (SerializationMemberInfo)m_AttributeMembersMap[state.Parameters.Namespaces.GetNamespace(reader.Prefix) + (char)0xff + reader.LocalName];
}
else
{
serializationMember = (SerializationMemberInfo)m_AttributeMembersMap[reader.Name];
}
if (serializationMember == null)
{
// Unknown attribute.
if (uhm != null)
{
uhm.UnhandledAttribute(reader.Name, reader.Value);
}
}
else
{
serializationMember.SetValue(retval, serializationMember.Serializer.Deserialize(reader, state));
}
}
reader.MoveToElement();
}
if (reader.IsEmptyElement)
{
reader.ReadStartElement();
return(retval);
}
reader.ReadStartElement();
// Read elements
while (true)
{
XmlReaderHelper.ReadUntilAnyTypesReached(reader,
new XmlNodeType[] { XmlNodeType.Element, XmlNodeType.EndElement });
if (reader.NodeType == XmlNodeType.Element)
{
if (reader.Prefix.Length > 0)
{
serializationMember = (SerializationMemberInfo)m_ElementMembersMap[state.Parameters.Namespaces.GetNamespace(reader.Prefix) + (char)0xff + reader.LocalName];
}
else
{
serializationMember = (SerializationMemberInfo)m_ElementMembersMap[reader.LocalName];
}
if (serializationMember == null)
{
// Unknown element.
reader.Read();
XmlReaderHelper.ReadAndApproachMatchingEndElement(reader);
}
else
{
if (serializationMember.SerializeAsValueNodeAttributeName != null &&
serializationMember.Serializer is TypeSerializerWithSimpleTextSupport)
{
string s;
s = reader.GetAttribute(serializationMember.SerializeAsValueNodeAttributeName);
serializationMember.SetValue(retval, ((TypeSerializerWithSimpleTextSupport)(serializationMember.Serializer)).Deserialize(s, state));
XmlReaderHelper.ReadAndConsumeMatchingEndElement(reader);
}
else
{
serializationMember.SetValue(retval, serializationMember.Serializer.Deserialize(reader, state));
}
}
}
else
{
if (reader.NodeType == XmlNodeType.EndElement)
{
reader.ReadEndElement();
}
else
{
if (uhm != null)
{
uhm.UnhandledOther(reader.ReadOuterXml());
}
}
break;
}
}
state.DeserializationEnd(retval);
return(retval);
}
