private Type DeserializeItemsFromElements(Type entityType, IList parent, ListPropertyDescriptor metadata, XmlReader reader, XmlSerializerContext context)
{
ListItemPropertyDescriptor propDesc = metadata.GetItemPropertyDescriptor(context, false);
//avanzo hasta la posicion del elemento
string nodeName = reader.LocalName;
//avanzo hasta el primer nodo
bool end = !reader.Read();
XmlNodeType typeNode = reader.MoveToContent();
object association;
Type itemType = null;
//parseo las propiedades
while (!end)
{
//me fijo si la propiedad es vacia
if (reader.NodeType != XmlNodeType.EndElement)
{
//obtengo el tipo por el atributo
itemType = base.GetEntityTypeForElement(propDesc, reader, context);
if (itemType != null)
{
IXmlConverter converter = context.GetConverter(itemType);
association = converter.FromXml(parent, propDesc, itemType, reader, context);
if (association != null || context.Settings.AddNullValueInLists)
{
//agrego el item a la lista
parent.Add(association);
}
}
else
{
reader.Skip();
}
}
//avanzo...
typeNode = reader.MoveToContent();
end = reader.NodeType == XmlNodeType.EndElement && reader.LocalName.Equals(nodeName);
}
reader.Read();
if (entityType.IsArray && itemType != null)
{
return(itemType);
}
else
{
return(metadata.DeclaringItemType);
}
}
private void DeserializeKeyValueAtttributes(IDictionary parent, DictionaryKeyValuePropertyDescriptor keyDesc, DictionaryKeyValuePropertyDescriptor valueDesc, XmlReader reader, XmlSerializerContext context, out object key, out object value)
{
string attName;
Type keyType;
Type valueType;
key = null;
value = null;
if (reader.MoveToFirstAttribute())
{
attName = reader.Name;
keyType = keyDesc.GetTypeFromAttributeName(attName, context);
if (keyType == null)
{
valueType = valueDesc.GetTypeFromAttributeName(attName, context);
if (valueType != null)
{
IXmlConverter converter = context.GetConverter(valueType);
value = converter.FromXml(parent, valueDesc, valueType, reader, context);
}
}
else
{
IXmlConverter converter = context.GetConverter(keyType);
key = converter.FromXml(parent, keyDesc, keyType, reader, context);
}
if (reader.MoveToNextAttribute())
{
attName = reader.Name;
keyType = keyDesc.GetTypeFromAttributeName(attName, context);
if (keyType == null)
{
valueType = valueDesc.GetTypeFromAttributeName(attName, context);
if (valueType != null)
{
IXmlConverter converter = context.GetConverter(valueType);
value = converter.FromXml(parent, valueDesc, valueType, reader, context);
}
}
else
{
IXmlConverter converter = context.GetConverter(keyType);
key = converter.FromXml(parent, keyDesc, keyType, reader, context);
}
}
}
//me ubico en el elemento..
reader.MoveToContent();
}
private void DeserializeElements(object parent, TypeDescriptor entityTypeDescriptor, XmlReader reader, XmlSerializerContext context)
{
string nodeName = reader.LocalName;
//avanzo hasta la posicion del elemento
bool end = !reader.Read();
XmlNodeType typeNode = reader.MoveToContent();
object association;
PropertyDescriptor prop;
//parseo las propiedades
while (!end)
{
//me fijo si la propiedad es vacia
if (reader.NodeType != XmlNodeType.EndElement)
{
prop = entityTypeDescriptor.GetPropertyByElementName(reader.LocalName);
if (prop != null)
{
Type xmlType = base.GetEntityTypeForElement(prop, reader, context);
if (xmlType != null)
{
IXmlConverter converter = context.GetConverter(xmlType);
association = converter.FromXml(parent, prop, xmlType, reader, context);
prop.Metadata.SetValue(parent, association);
}
else
{
reader.Skip();
}
}
else
{
//DefaultLogger.Warning("The xml element {0} doesn't match with a property of the class {1}", reader.LocalName, parent.GetType().ToString());
reader.Skip();
}
}
typeNode = reader.MoveToContent();
end = reader.NodeType == XmlNodeType.EndElement && reader.LocalName.Equals(nodeName);
}
reader.Read();
}
private void DeserializeAttributes(object parent, TypeDescriptor entityTypeDescriptor, XmlReader reader, XmlSerializerContext context)
{
//avanzo hasta el primer atributo
bool isAtt = reader.MoveToFirstAttribute();
PropertyDescriptor prop;
//si es un atributo, el tipo de la entidad coincide con el definido en la propiedad...
string attName;
object value;
if (isAtt)
{
do
{
attName = reader.Name;
prop = entityTypeDescriptor.GetPropertyByAttributeName(attName);
if (prop != null)
{
//obtengo el tipo a partir del atributo
Type propType = prop.GetTypeFromAttributeName(attName, context);
IXmlConverter converter = context.GetConverter(propType);
value = converter.FromXml(parent, prop, propType, reader, context);
prop.Metadata.SetValue(parent, value);
}
else
{
//if (! (string.Compare(context.Settings.TypeSettings.AttributeTypeName, attName) == 0
// || string.Compare(XmlSerializerSettings.ObjectReferenceAttributeName, attName) == 0
// || string.Compare(XmlSerializerSettings.ObjectIdAttributeName, attName) == 0))
//DefaultLogger.Warning("The xml attribute {0} doesn't match with an property of the class {1}", attName, parent.GetType().ToString());
}
}while (reader.MoveToNextAttribute());
}
//me ubico de nuevo en el elemento
reader.MoveToContent();
}
private void DeserializeKeyValueElements(IDictionary parent, DictionaryKeyValuePropertyDescriptor keyDesc, DictionaryKeyValuePropertyDescriptor valueDesc, XmlReader reader, XmlSerializerContext context, ref object key, ref object value)
{
string nodeName = reader.LocalName;
//avanzo hasta la posicion del elemento
bool end = !reader.Read();
XmlNodeType typeNode = reader.MoveToContent();
string elementName;
Type keyType;
Type valueType;
//parseo las propiedades
while (!end)
{
//me fijo si la propiedad es vacia
if (reader.NodeType != XmlNodeType.EndElement)
{
elementName = reader.LocalName;
keyType = keyDesc.GetTypeFromElementName(elementName, context);
if (keyType == null)
{
valueType = valueDesc.GetTypeFromElementName(elementName, context);
if (valueType != null)
{
IXmlConverter converter = context.GetConverter(valueType);
value = converter.FromXml(parent, valueDesc, valueType, reader, context);
}
}
else
{
IXmlConverter converter = context.GetConverter(keyType);
key = converter.FromXml(parent, keyDesc, keyType, reader, context);
}
//ya esta parado sobre el siguiente elemento
typeNode = reader.MoveToContent();
if (reader.NodeType != XmlNodeType.EndElement)
{
elementName = reader.LocalName;
keyType = keyDesc.GetTypeFromElementName(elementName, context);
if (keyType == null)
{
valueType = valueDesc.GetTypeFromElementName(elementName, context);
if (valueType != null)
{
IXmlConverter converter = context.GetConverter(valueType);
value = converter.FromXml(parent, valueDesc, valueType, reader, context);
}
}
else
{
IXmlConverter converter = context.GetConverter(keyType);
key = converter.FromXml(parent, keyDesc, keyType, reader, context);
}
}
}
typeNode = reader.MoveToContent();
end = reader.NodeType == XmlNodeType.EndElement && reader.LocalName.Equals(nodeName);
}
}
public virtual object Deserialize(Type rootType, string rootElementName, XmlReader reader)
{
using (reader)
{
XmlNodeType typeNode = reader.MoveToContent();
if (typeNode == XmlNodeType.Element || typeNode == XmlNodeType.EndElement)
{
XmlSerializerContext context = this.CreateContext();
Type type = context.GetTypeFromAttribute(reader);
if (type == null)
{
type = context.GetTypeFromAlias(reader.LocalName);
}
if (type == null)
{
if (rootType != null)
{
type = rootType;
}
else
{
throw new Exception("No es posible obtener tipo del objeto a deserializar cuyo nombre de elemento raíz es " + reader.LocalName);
}
}
object holder = this.CreateObjectHolder(type, null);
TypeDescriptor holderDesc = new TypeDescriptor(holder.GetType());
if (holderDesc.Properties.Count == 0)
{
throw new SerializationException("The type is not marked as serializable.");
}
PropertyDescriptor desc = holderDesc.Properties[0];
RootPropertyMetadata metadata;
if (string.IsNullOrEmpty(rootElementName))
{
rootElementName = this.GetElementName(type, context);
}
metadata = new RootPropertyMetadata(rootElementName, desc.Metadata.DefaultAttributeName, desc.Metadata);
desc.Metadata = metadata;
desc.UseAlias = true;
this.Context = context;
IXmlConverter converter = context.GetConverter(type);
object output = converter.FromXml(holder, desc, type, reader, context);
return(output);
}
else
{
return(null);
}
}
}
