protected override object DoFromXml(object parent, PropertyDescriptor propDesc, Type entityType, XmlReader reader, XmlSerializerContext context)
{
long id = this.GetInstanceId(reader);
string nodeName = reader.LocalName;
DictionaryPropertyDescriptor metadata = propDesc.GetPropertyDescriptor <DictionaryPropertyDescriptor>(entityType, context);
IDictionary items = (IDictionary)Activator.CreateInstance(entityType, true);
//recorro todos los items
if (reader.NodeType == XmlNodeType.EndElement || reader.IsEmptyElement)
{
//avanzo
if (reader.IsEmptyElement)
{
reader.Read(); //avanzo para ubicarme en el siguiente nodo.
}
}
else
{
this.DeserializeElements(items, metadata, reader, context);
}
//agrego el diccionario al stack
context.Stack.AddInstance(id, items);
//creo un array
return(items);
}
protected override object DoFromXml(object parent, PropertyDescriptor metadata, Type entityType, XmlReader reader, XmlSerializerContext context)
{
string attributeName = null;
string elementName = null;
string val = null;
object output = null;
ValueTypePropertyDescriptor valPropDesc = metadata.GetPropertyDescriptor <ValueTypePropertyDescriptor>(entityType, context);
//si el reader esta parado sobre un atributo.....entonces, el tipo lo obtengo a partir del atributo
if (reader.NodeType == XmlNodeType.Attribute)
{
attributeName = reader.Name;
}
else
{
elementName = reader.LocalName;
attributeName = valPropDesc.GetAttributeNameForType(entityType, context);
}
if (string.IsNullOrEmpty(elementName))
{
//esta definido en el atributo, lo escribo
string propAttName = valPropDesc.GetAttributeNameForType(entityType, context);
if (string.Compare(attributeName, propAttName) == 0)
{
val = reader.Value;
output = this.GetValueFromString(valPropDesc.GetPropertyDescriptor <ValueTypePropertyDescriptor>(entityType, context), val, entityType, context);
}
}
else
{
if (string.IsNullOrEmpty(attributeName))
{
val = reader.ReadElementContentAsString();
}
else
{
if (reader.MoveToAttribute(attributeName))
{
//avanzo el elemento
val = reader.Value;
reader.Read();
}
else
{
//esta en el contenido del elemento
val = reader.ReadElementContentAsString();
}
}
output = this.GetValueFromString(valPropDesc, val, entityType, context);
}
return(output);
}
protected override void DoToXml(object parent, PropertyDescriptor propDescritor, object entity, XmlTextWriter writer, XmlSerializerContext context)
{
Type entityType = entity.GetType();
ValueTypePropertyDescriptor metadata = propDescritor.GetPropertyDescriptor <ValueTypePropertyDescriptor>(entityType, context);
if (metadata.IsXmlContentText)
{
if (!TypeHelper.IsDefaultValue(entity, entityType) || context.Settings.WriteDefaultValues)
{
string valueStr = this.GetValueAsString(metadata, entity, entityType, context);
string elementName = metadata.GetElementNameForType(entityType, context, true);
//escribo el nombre del elemento...
writer.WriteStartElement(elementName);
//recorro el contenido
StringReader stringReader = new StringReader(valueStr);
XmlTextReader reader = new XmlTextReader(stringReader);
try
{
reader.MoveToContent();
//recorro todos los attributos y los escribo en el destino
if (reader.MoveToFirstAttribute())
{
writer.WriteAttributeString(reader.LocalName, reader.Value);
while (reader.MoveToNextAttribute())
{
writer.WriteAttributeString(reader.LocalName, reader.Value);
}
}
reader.MoveToContent();
string str = reader.ReadInnerXml();
writer.WriteRaw(str);
}
finally
{
stringReader.Close();
reader.Close();
}
//cierro el tag
writer.WriteEndElement();
}
}
else
{
base.DoToXml(parent, metadata, entity, writer, context);
}
}
protected override object DoFromXml(object parent, PropertyDescriptor propDesc, Type entityType, XmlReader reader, XmlSerializerContext context)
{
ValueTypePropertyDescriptor metadata = propDesc.GetPropertyDescriptor <ValueTypePropertyDescriptor>(entityType, context);
if (metadata.IsXmlContentText)
{
//tengo que leer todo el contenido...
return(string.Intern(reader.ReadOuterXml()));
}
else
{
return(base.DoFromXml(parent, metadata, entityType, reader, context));
}
}
protected override void DoToXml(object parent, PropertyDescriptor metadata, object entity, XmlTextWriter writer, XmlSerializerContext context)
{
Type entityType = entity.GetType();
TypeDescriptor entityTypeDescriptor = context.GetTypeDescriptor(entityType);
//no es serializable...
if (entityTypeDescriptor == null)
{
return;
}
ObjectPropertyDescriptor descriptor = metadata.GetPropertyDescriptor <ObjectPropertyDescriptor>(entityType, context);
string elementName = metadata.GetElementNameForType(entityType, context, true);
//escribo el nombre de la propiedad
writer.WriteStartElement(elementName);
if (!context.Settings.UniqueSerializationForInstance || !context.Stack.ContainsInstance(entity))
{
//agrego la lista a las entidades registradas
long id = context.Stack.AddInstance(entity);
//escribo las propiedades que son atributos
this.WriteProperties(metadata, entity, entityTypeDescriptor, writer, context, true);
//agrego el tipo de la entidad como ultimo atributo
base.WriteTypeDefinition(descriptor, entityType, context, writer);
//escribo el id del objeto
if (context.Settings.UniqueSerializationForInstance)
{
writer.WriteAttributeString(XmlSerializerSettings.ObjectIdAttributeName, id.ToString());
}
//escribo las propiedades que son elementos
this.WriteProperties(metadata, entity, entityTypeDescriptor, writer, context, false);
}
else
{
//me fijo si ya existe en el context
long id = context.Stack.GetInstanceReferenceId(entity);
writer.WriteAttributeString(XmlSerializerSettings.ObjectReferenceAttributeName, id.ToString());
}
//escribo el nombre de la propiedad
writer.WriteEndElement();
}
protected override void DoToNullValueXml(object parent, PropertyDescriptor metadata, XmlTextWriter writer, XmlSerializerContext context)
{
Type entityType = metadata.Metadata.PropertyType;
ValueTypePropertyDescriptor desc = metadata.GetPropertyDescriptor <ValueTypePropertyDescriptor>(entityType, context);
if (!desc.IsXmlElement(entityType, context))
{
string attributeName = metadata.GetAttributeNameForType(entityType, context);
//esta definido el atributo, lo escribo
writer.WriteAttributeString(attributeName, "");
}
else
{
string elementName = desc.GetElementNameForType(entityType, context, true);
//escribo el nombre de la propiedad
writer.WriteElementString(elementName, "");
}
}
protected override void DoToXml(object parent, PropertyDescriptor propDesc, object entity, XmlTextWriter writer, XmlSerializerContext context)
{
Type entityType = entity.GetType();
DictionaryPropertyDescriptor metadata = propDesc.GetPropertyDescriptor <DictionaryPropertyDescriptor>(entityType, context);
string nodeName = metadata.GetElementNameForType(entityType, context, true);
writer.WriteStartElement(nodeName);
if (!context.Settings.UniqueSerializationForInstance || !context.Stack.ContainsInstance(entity))
{
//agrego la lista a las entidades registradas
long id = context.Stack.AddInstance(entity);
base.WriteTypeDefinition(metadata, entityType, context, writer);
//escribo el id del objeto si corresponde
if (context.Settings.UniqueSerializationForInstance)
{
writer.WriteAttributeString(XmlSerializerSettings.ObjectIdAttributeName, id.ToString());
}
IDictionary dic = (IDictionary)entity;
DictionaryKeyValuePropertyDescriptor keyDesc = metadata.GetDictionaryItemKeyPropertyDescriptor(context);
DictionaryKeyValuePropertyDescriptor valueDesc = metadata.GetDictionaryItemValuePropertyDescriptor(context);
foreach (DictionaryEntry item in dic)
{
this.SerializeDictionaryItem(dic, item, metadata, keyDesc, valueDesc, writer, context);
}
}
else
{
//me fijo si ya existe en el context
long id = context.Stack.GetInstanceReferenceId(entity);
writer.WriteAttributeString(XmlSerializerSettings.ObjectReferenceAttributeName, id.ToString());
}
writer.WriteEndElement();
}
protected override void DoToXml(object parent, PropertyDescriptor metadata, object entity, XmlTextWriter writer, XmlSerializerContext context)
{
Type entityType = entity.GetType();
if (!TypeHelper.IsDefaultValue(entity, entityType) || context.Settings.WriteDefaultValues)
{
ValueTypePropertyDescriptor desc = metadata.GetPropertyDescriptor <ValueTypePropertyDescriptor>(entityType, context);
string valueStr = this.GetValueAsString(desc, entity, entityType, context);
if (!desc.IsXmlElement(entityType, context))
{
string attributeName = metadata.GetAttributeNameForType(entityType, context);
//esta definido el atributo, lo escribo
writer.WriteAttributeString(attributeName, valueStr);
}
else
{
string elementName = desc.GetElementNameForType(entityType, context, true);
//escribo el nombre de la propiedad
writer.WriteStartElement(elementName);
base.WriteTypeDefinition(desc, entityType, context, writer);
if (desc.IsXmlAttribute(entityType, context))
{
string attributeName = metadata.GetAttributeNameForType(entityType, context);
//escribo el valor
writer.WriteAttributeString(attributeName, valueStr);
}
else
{
writer.WriteRaw(valueStr);
}
//writer.WriteString(valueStr); si tiene caracteres de xml los convierte a &
//cierro el tag
writer.WriteEndElement();
}
}
}
protected override void DoToXml(object parent, PropertyDescriptor propDesc, object entity, XmlTextWriter writer, XmlSerializerContext context)
{
Type entityType = entity.GetType();
ListPropertyDescriptor metadata = propDesc.GetPropertyDescriptor <ListPropertyDescriptor>(entityType, context);
if (metadata.IsInlineAttributeArray(entityType, context))
{
this.WriteInlineArrayAsAttribute(parent, metadata, entity, entityType, writer, context);
}
else
{
//deberia validar si la lista ya se agrego....y colocar una referencia..
if (metadata.IsInlineElementArray(entityType, context))
{
this.WriteInlineArrayAsElement(parent, metadata, entity, entityType, writer, context);
}
else
{
this.WriteArrayAsElement(parent, metadata, entity, entityType, writer, context);
}
}
}
protected override object DoFromXml(object parent, PropertyDescriptor propDesc, Type entityType, XmlReader reader, XmlSerializerContext context)
{
//string nodeName = reader.LocalName;
ListPropertyDescriptor metadata = propDesc.GetPropertyDescriptor <ListPropertyDescriptor>(entityType, context);
IList items;
//creo una lista para luego transformarla en un array....si es una lista
if (entityType.IsArray)
{
items = new ArrayList();
}
else if (entityType.IsInterface)
{
if (entityType.IsGenericType)
{
Type entityItemType = entityType.GetGenericArguments()[0];
Type listType = typeof(List <>);
listType = listType.MakeGenericType(entityItemType);
items = (IList)Activator.CreateInstance(listType, true);
}
else
{
items = new ArrayList();
}
}
else
{
items = (IList)Activator.CreateInstance(entityType, true);
}
Type itemType;
long id = 0;
if (metadata.IsInlineAttributeArray(entityType, context))
{
itemType = this.DeserializeItemsFromInlineAttribute(entityType, items, metadata, reader, context);
}
else
{
//si no es inline el array, entonces tiene un id
id = this.GetInstanceId(reader);
//recorro todos los items
if (reader.NodeType == XmlNodeType.EndElement || reader.IsEmptyElement)
{
//avanzo
if (reader.IsEmptyElement)
{
reader.Read(); //avanzo para ubicarme en el siguiente nodo.
}
itemType = metadata.DeclaringItemType;
}
else
{
if (metadata.IsInlineElementArray(entityType, context))
{
itemType = this.DeserializeItemsFromInlineElements(items, metadata, reader, context);
}
else
{
itemType = this.DeserializeItemsFromElements(entityType, items, metadata, reader, context);
}
}
}
IList output;
//creo un array
if (entityType.IsArray)
{
output = this.CreateOutputFrom(metadata, items, entityType.GetElementType());
}
else
{
output = this.CreateOutputFrom(metadata, items, itemType);
}
//agrego la instancia al stack
context.Stack.AddInstance(id, output);
return(output);
}
/// <summary>
///
/// </summary>
/// <param name="parent"></param>
/// <param name="metadata"></param>
/// <param name="entity"></param>
/// <param name="writer"></param>
/// <param name="context"></param>
protected override void DoToXml(object parent, PropertyDescriptor metadata, object entity, XmlTextWriter writer, XmlSerializerContext context)
{
ConfigurationSection section = (ConfigurationSection)entity;
if (section == null)
{
return;
}
Type entityType = section.GetType();
string elementName = metadata.GetElementNameForType(entityType, context, true);
if (!context.Settings.UniqueSerializationForInstance || !context.Stack.ContainsInstance(entity))
{
//agrego la lista a las entidades registradas
long id = context.Stack.AddInstance(entity);
string valueStr = (string)SerializeMethod.Invoke(section, new object[] { null, elementName, ConfigurationSaveMode.Full });
//escribo el nombre del elemento...
writer.WriteStartElement(elementName);
//recorro el contenido
StringReader stringReader = new StringReader(valueStr);
XmlTextReader reader = new XmlTextReader(stringReader);
try
{
reader.MoveToContent();
//recorro todos los attributos y los escribo en el destino
if (reader.MoveToFirstAttribute())
{
writer.WriteAttributeString(reader.LocalName, reader.Value);
while (reader.MoveToNextAttribute())
{
writer.WriteAttributeString(reader.LocalName, reader.Value);
}
}
//me fijo si hay que escribir el id
//escribo el id del objeto si corresponde
if (context.Settings.UniqueSerializationForInstance)
{
writer.WriteAttributeString(XmlSerializerSettings.ObjectIdAttributeName, id.ToString());
}
//agrego el tipo de la entidad como ultimo atributo
ObjectPropertyDescriptor descriptor = metadata.GetPropertyDescriptor <ObjectPropertyDescriptor>(entityType, context);
base.WriteTypeDefinition(descriptor, entityType, context, writer);
reader.MoveToContent();
string str = reader.ReadInnerXml();
if (!string.IsNullOrEmpty(str))
{
writer.WriteRaw(str);
}
}
finally
{
stringReader.Close();
reader.Close();
}
//cierro el tag
writer.WriteEndElement();
}
else
{
writer.WriteStartElement(elementName);
//me fijo si ya existe en el context
long id = context.Stack.GetInstanceReferenceId(entity);
writer.WriteAttributeString(XmlSerializerSettings.ObjectReferenceAttributeName, id.ToString());
writer.WriteEndElement();
}
}