protected override void WriteValue(XmlWriter writer, object value)
{
IDictionary dictionary = (IDictionary)value;
foreach (object key in dictionary.Keys)
{
object target = dictionary[key];
// any way to refactor code block?
ReflectorTypeAttribute typeAttribute = ReflectorTypeAttribute.GetAttribute(target);
if (typeAttribute == null)
{
writer.WriteStartElement(elementName);
writer.WriteAttributeString(attribute.Key, key.ToString());
writer.WriteString(target.ToString());
writer.WriteEndElement();
}
else
{
writer.WriteStartElement(typeAttribute.Name);
writer.WriteAttributeString(attribute.Key, key.ToString());
XmlTypeSerialiser serialiser = (XmlTypeSerialiser)typeAttribute.CreateSerialiser(target.GetType());
serialiser.WriteMembers(writer, target);
writer.WriteEndElement();
}
}
}
public void Write(object target)
{
NetReflector.CheckNull(target, "target", typeof(object));
ReflectorTypeAttribute attribute = ReflectorTypeAttribute.GetAttribute(target);
if (attribute == null)
{
throw new NetReflectorException(string.Format("Cannot serialise the object. Target object type ({0}) is not marked with a ReflectorType attribute.", target.GetType()));
}
attribute.Write(writer, target);
}
protected virtual void WriteValue(XmlWriter writer, object value)
{
ReflectorTypeAttribute attribute = ReflectorTypeAttribute.GetAttribute(value);
if (attribute == null)
{
writer.WriteString(value.ToString());
}
else
{
XmlTypeSerialiser serialiser = (XmlTypeSerialiser)attribute.CreateSerialiser(value.GetType());
serialiser.WriteMembers(writer, value);
}
}
public virtual void Write(XmlWriter writer, object target)
{
object value = member.GetValue(target);
if (value != null && IsSerializableValue(value))
{
writer.WriteStartElement(attribute.Name);
if (attribute.InstanceTypeKey != null)
{
ReflectorTypeAttribute typeAttribute = ReflectorTypeAttribute.GetAttribute(value);
writer.WriteAttributeString(attribute.InstanceTypeKey, typeAttribute.Name);
}
WriteValue(writer, value);
writer.WriteEndElement();
}
}
protected virtual object Read(XmlNode childNode, Type instanceType, NetReflectorTypeTable table)
{
if (ReflectionUtil.IsCommonType(instanceType))
{
if ((childNode.Attributes != null) && (childNode.Attributes.Count > 0))
{
throw new NetReflectorException(
string.Format("Attributes are not allowed on {3} types - {0} attributes(s) found on '{1}'" + Environment.NewLine +
"Xml: {2}",
childNode.Attributes.Count,
childNode.Name,
childNode.OuterXml,
instanceType.Name));
}
return(childNode.InnerText);
}
else
{
ReflectorTypeAttribute reflectorTypeAttribute = ReflectorTypeAttribute.GetAttribute(instanceType);
if (reflectorTypeAttribute == null)
{
if (!string.IsNullOrEmpty(attribute.InstanceTypeKey))
{
throw new NetReflectorException(
string.Format("Unable to find reflector type for '{0}' when deserialising '{1}' - '{3}' has not been set" + Environment.NewLine +
"Xml: {2}",
instanceType.Name,
childNode.Name,
childNode.OuterXml,
attribute.InstanceTypeKey));
}
else
{
throw new NetReflectorException(
string.Format("Unable to find reflector type for '{0}' when deserialising '{1}'" + Environment.NewLine +
"Xml: {2}",
instanceType.Name,
childNode.Name,
childNode.OuterXml));
}
}
IXmlSerialiser serialiser = table[reflectorTypeAttribute.Name];
// null check
return(serialiser.Read(childNode, table));
}
}
public void Add(Type type)
{
ReflectorTypeAttribute attribute = ReflectorTypeAttribute.GetAttribute(type);
if (attribute == null)
{
return;
}
if (!reflectorTypes.Contains(attribute.Name))
{
IXmlSerialiser serialiser = attribute.CreateSerialiser(type, instantiator);
reflectorTypes.Add(attribute.Name, serialiser);
}
else if (type != this[attribute.Name].Type)
{
throw new NetReflectorException(string.Format(@"Multiple types exist with the same ReflectorTypeAttribute name ""{0}"": ({1}, {2})",
attribute.Name, type, this[attribute.Name].Type));
}
}
protected override void WriteValue(XmlWriter writer, object value)
{
foreach (object element in ((IEnumerable)value))
{
if (element == null)
{
continue;
}
ReflectorTypeAttribute attribute = ReflectorTypeAttribute.GetAttribute(element);
if (attribute == null)
{
writer.WriteElementString(elementName, element.ToString());
}
else
{
// make more concise?
IXmlSerialiser serialiser = attribute.CreateSerialiser(element.GetType());
serialiser.Write(writer, element);
}
}
}
private bool IsSerializableValue(object value)
{
return(attribute.InstanceTypeKey == null || ReflectorTypeAttribute.GetAttribute(value) != null);
}
