public override object Deserialize(string value, SerializationContext state)
{
bool ok = verifyAttributes.Length == 0;
var type = Type.GetType(value);
if (type == null)
{
throw new TypeLoadException("The type could not be loaded: " + value);
}
foreach (XmlVerifyRuntimeTypeAttribute attribute in verifyAttributes)
{
if (attribute.VerifiesAgainst(type))
{
ok = true;
break;
}
}
if (!ok)
{
throw new XmlSerializerException("Invalid type");
}
return type;
}
public override object Deserialize(System.Xml.XmlReader reader, SerializationContext state)
{
var document = new XmlDocument();
document.LoadXml(reader.ReadOuterXml());
return document.FirstChild;
}
/// <summary>
/// <see cref="TypeSerializerWithSimpleTextSupport.Deserialize(string, SerializationContext)"/>
/// </summary>
public override object Deserialize(string value, SerializationContext state)
{
if (formatSpecified)
{
return Convert.ChangeType(value, supportedType, formatAttribute.CultureInfo);
}
return Convert.ChangeType(value, supportedType);
}
public override void Serialize(object obj, System.Xml.XmlWriter writer, SerializationContext state)
{
foreach (XmlNode child in ((XmlNode)obj).ChildNodes)
{
var reader = new XmlNodeReader(child);
WriteNode(reader, writer);
}
}
public override object Deserialize(XmlReader reader, SerializationContext state)
{
var s = XmlReaderHelper.ReadCurrentNodeValue(reader);
if (state.GetCurrentMemberInfo().Substitutor != null)
{
s = state.GetCurrentMemberInfo().Substitutor.Substitute(s);
}
return Deserialize(s, state);
}
/// <summary>
/// <see cref="TypeSerializerWithSimpleTextSupport.Deserialize(string, SerializationContext)"/>
/// </summary>
public override object Deserialize(string value, SerializationContext state)
{
try
{
return ColorTranslator.FromHtml(value);
}
catch (Exception)
{
return Color.FromName(value);
}
}
public override string Serialize(object obj, SerializationContext state)
{
var attribute = (XmlSerializeEnumAsIntAttribute)state.GetCurrentMemberInfo().GetFirstApplicableAttribute(typeof(XmlSerializeEnumAsIntAttribute));
if (attribute != null && attribute.Value)
{
return Convert.ToInt32(obj).ToString();
}
return Enum.Format(supportedType, obj, "G");
}
/// <summary>
/// <see cref="TypeSerializerWithSimpleTextSupport.Serialize(object, SerializationContext)"/>
/// </summary>
public override string Serialize(object obj, SerializationContext state)
{
if (obj is IFormattable && formatSpecified)
{
return (obj as IFormattable).ToString(formatAttribute.Format, formatAttribute.CultureInfo);
}
if (obj == null)
{
return string.Empty;
}
return obj.ToString();
}
public override object Deserialize(string value, SerializationContext state)
{
if (formatSpecified)
{
try
{
return DateTime.ParseExact(value, formatAttribute.Format, formatAttribute.CultureInfo);
}
catch
{
}
}
return DateTime.Parse(value);
}
public override string Serialize(object obj, SerializationContext state)
{
if (obj == null)
{
return "";
}
if (((Color)obj).ToKnownColor() != 0)
{
return ((Color)obj).Name;
}
else
{
return ColorTranslator.ToHtml((Color)obj);
}
}
public override string Serialize(object obj, SerializationContext state)
{
var ok = verifyAttributes.Length == 0;
foreach (XmlVerifyRuntimeTypeAttribute attribute in verifyAttributes)
{
if (attribute.VerifiesAgainst(obj.GetType()))
{
ok = true;
break;
}
}
if (!ok)
{
throw new XmlSerializerException("Invalid type");
}
return ((Type)obj).AssemblyQualifiedName;
}
public override object Deserialize(XmlReader reader, SerializationContext state)
{
var retval = base.Deserialize(reader, state);
if (listType.IsArray)
{
int count;
if (retval is System.Collections.IList)
{
count = ((System.Collections.IList)retval).Count;
}
else
{
count = (int)retval.GetType().GetProperty("Count", BindingFlags.Instance | BindingFlags.Public).GetValue(retval, new object[0]);
}
var array = Array.CreateInstance(listType.GetElementType(), count);
state.DeserializationStart(retval);
if (retval is System.Collections.IList)
{
((System.Collections.IList)retval).CopyTo(array, 0);
}
else
{
retval.GetType().GetMethod
(
"CopyTo",
BindingFlags.Instance | BindingFlags.Public
).Invoke(retval, new object[] { array, 0 });
}
retval = array;
}
state.DeserializationEnd(retval);
return retval;
}
protected override void DeserializeElement(object obj, XmlReader reader, SerializationContext state)
{
DictionaryItem dictionaryItem;
var typeAlias = reader.GetAttribute("typealias");
if (!string.IsNullOrEmpty(typeAlias))
{
if (!aliasToItemMap.TryGetValue(reader.GetAttribute("typealias"), out dictionaryItem))
{
dictionaryItem = primaryDictionaryItem;
}
}
else
{
dictionaryItem = primaryDictionaryItem;
}
var key = reader.LocalName;
var value = dictionaryItem.serializer.Deserialize(reader, state);
((IDictionary)obj)[key] = value;
}
protected virtual void DeserializeText(object obj, XmlReader reader, SerializationContext state)
{
if (TextMember == null)
return;
state.PushCurrentMemberInfo(TextMember);
object value;
try
{
value = TextMember.GetSerializer(reader).Deserialize(reader, state);
}
finally
{
state.PopCurrentMemberInfo();
}
TextMember.SetValue(obj, value);
}
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();
}
}
}
protected virtual void DeserializeAttribute(object obj, XmlReader reader, SerializationContext state)
{
object value;
SerializationMemberInfo serializationMember;
if (reader.Prefix == "xmlns")
{
return;
}
if (reader.Prefix.Length > 0)
{
serializationMember = (SerializationMemberInfo)attributeMembersMap[state.Parameters.Namespaces.GetNamespace(reader.Prefix) + (char)0xff + reader.LocalName];
}
else
{
serializationMember = (SerializationMemberInfo)attributeMembersMap[reader.Name];
}
if (serializationMember == null)
{
if (obj is ISerializationUnhandledMarkupListener)
{
((ISerializationUnhandledMarkupListener)obj).UnhandledAttribute(reader.Name, reader.Value);
}
return;
}
state.PushCurrentMemberInfo(serializationMember);
try
{
value = serializationMember.GetSerializer(reader).Deserialize(reader, state);
}
finally
{
state.PopCurrentMemberInfo();
}
serializationMember.SetValue(obj, value);
}
protected virtual object CreateInstance(XmlReader reader, SerializationContext state)
{
return Activator.CreateInstance(supportedType);
}
protected virtual bool CanDeserializeElement(object obj, XmlReader reader, SerializationContext state)
{
if (reader.Prefix.Length > 0)
{
return (SerializationMemberInfo)elementMembersMap[state.Parameters.Namespaces.GetNamespace(reader.Prefix) + (char)0xff + reader.LocalName] != null;
}
else
{
return (SerializationMemberInfo)elementMembersMap[reader.LocalName] != null;
}
}
protected override void SerializeElements(object obj, XmlWriter writer, SerializationContext state)
{
base.SerializeElements (obj, writer, state);
foreach (var item in (System.Collections.IEnumerable)obj)
{
if (state.ShouldSerialize(item, this.serializationMemberInfo))
{
ListItem listItem;
if (TryGetItemByType(item.GetType(), out listItem))
{
writer.WriteStartElement(listItem.Alias);
if (listItem.Attribute != null
&& listItem.Attribute.SerializeAsValueNode
&& listItem.Attribute.ValueNodeAttributeName != null
&& listItem.Serializer is TypeSerializerWithSimpleTextSupport)
{
writer.WriteAttributeString(listItem.Attribute.ValueNodeAttributeName,
((TypeSerializerWithSimpleTextSupport)listItem.Serializer).Serialize(item, state));
}
else
{
listItem.Serializer.Serialize(item, writer, state);
}
}
else
{
if (this.dynamicTypeResolver == null)
{
throw new XmlSerializerException();
}
else
{
var type = this.dynamicTypeResolver.GetType(item);
if (type == null)
{
throw new XmlSerializerException();
}
var serializer = cache.GetTypeSerializerBySupportedType(type);
writer.WriteStartElement(this.dynamicTypeResolver.GetName(item));
serializer.Serialize(item, writer, state);
}
}
writer.WriteEndElement();
}
}
}
protected virtual void SerializeText(object obj, XmlWriter writer, SerializationContext state)
{
//Nothing to serialize
if (TextMember == null)
return;
var memberInfo = TextMember;
object val;
// Get the value of the field/property to be serialized from the object
val = memberInfo.GetValue(obj);
// If the valuetype field should be treated as null if it is empty then make val null.
if (memberInfo.TreatAsNullIfEmpty)
{
if (memberInfo.ReturnType.IsValueType)
{
if (Activator.CreateInstance(memberInfo.ReturnType).Equals(val))
{
val = null;
}
}
}
// Make sure we aren't serializing recursively.
if (state.ShouldSerialize(val,memberInfo))
{
try
{
state.PushCurrentMemberInfo(memberInfo);
// Get the TypeSerializerWithSimpleTextSupport
var simpleSerializer = memberInfo.GetSerializer(obj) as TypeSerializerWithSimpleTextSupport;
// Make sure the serializer supports SimpleText
if (simpleSerializer == null)
{
throw new XmlSerializerException(String.Format(TextResources.NoTextSerializerWithSimpleTextSupport, memberInfo.MemberInfo.Name));
}
if (memberInfo.SerializeAsCData)
{
writer.WriteCData(simpleSerializer.Serialize(val, state));
}
else
{
writer.WriteString(simpleSerializer.Serialize(val, state));
}
}
finally
{
state.PopCurrentMemberInfo();
}
}
}
public override object Deserialize(string value, SerializationContext state)
{
return Enum.Parse(supportedType, value, true);
}
/// <summary> /// /// </summary> /// <param name="obj"></param> /// <param name="writer"></param> /// <param name="state"></param> public abstract void Serialize(object obj, XmlWriter writer, SerializationContext state);
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;
}
protected virtual void SerializeAttributes(object obj, XmlWriter writer, SerializationContext state)
{
foreach (SerializationMemberInfo memberInfo in attributeMembersMap.Values)
{
object val;
// Get the value of the field/property to be serialized from the object
val = memberInfo.GetValue(obj);
// If the valuetype field should be treated as null if it is empty then make val null.
if (memberInfo.TreatAsNullIfEmpty)
{
if (memberInfo.ReturnType.IsValueType)
{
if (Activator.CreateInstance(memberInfo.ReturnType).Equals(val))
{
val = null;
}
}
}
// Make sure we aren't serializing recursively.
if (state.ShouldSerialize(val,memberInfo))
{
try
{
state.PushCurrentMemberInfo(memberInfo);
// Get the TypeSerializerWithSimpleTextSupport
var simpleSerializer = memberInfo.GetSerializer(obj) as TypeSerializerWithSimpleTextSupport;
// Make sure the serializer supports SimpleText
if (simpleSerializer == null)
{
throw new XmlSerializerException(String.Format(TextResources.NoTextSerializerWithSimpleTextSupport, memberInfo.MemberInfo.Name));
}
// Write the start of the attribute.
writer.WriteStartAttribute(memberInfo.SerializedName);
// Write the attribute value.
writer.WriteString(simpleSerializer.Serialize(val, state));
// Write the end of the attribute
writer.WriteEndAttribute();
}
finally
{
state.PopCurrentMemberInfo();
}
}
}
}
public override object Deserialize(string value, SerializationContext state)
{
return(Enum.Parse(supportedType, value, true));
}
protected virtual void SerializeElements(object obj, XmlWriter writer, SerializationContext state)
{
foreach (SerializationMemberInfo memberInfo in elementMembersMap.Values)
{
state.PushCurrentMemberInfo(memberInfo);
try
{
object val;
val = memberInfo.GetValue(obj);
if (memberInfo.TreatAsNullIfEmpty)
{
if (memberInfo.ReturnType.IsValueType)
{
if (Activator.CreateInstance(memberInfo.ReturnType).Equals(val))
{
val = null;
}
}
}
var serializer = memberInfo.GetSerializer(val);
var serializerWithSimpleText = serializer as TypeSerializerWithSimpleTextSupport;
if (state.ShouldSerialize(val,memberInfo))
{
if (memberInfo.Namespace.Length > 0)
{
// Write start element with namespace
writer.WriteStartElement(state.Parameters.Namespaces.GetPrefix(memberInfo.Namespace), memberInfo.SerializedName, memberInfo.Namespace);
}
else
{
// Write start element without namespace
writer.WriteStartElement(memberInfo.SerializedName);
}
if (memberInfo.SerializeAsValueNodeAttributeName != null)
{
if (serializerWithSimpleText == null)
{
throw new XmlSerializerException(String.Format(TextResources.NoTextSerializerWithSimpleTextSupport, memberInfo.MemberInfo.Name));
}
writer.WriteAttributeString(memberInfo.SerializeAsValueNodeAttributeName, serializerWithSimpleText.Serialize(val, state));
}
else if (memberInfo.SerializeAsCData)
{
if (serializerWithSimpleText == null)
{
throw new XmlSerializerException(String.Format(TextResources.NoTextSerializerWithSimpleTextSupport, memberInfo.MemberInfo.Name));
}
writer.WriteCData(serializerWithSimpleText.Serialize(val, state));
}
else
{
memberInfo.GetSerializer(val).Serialize(val, writer, state);
}
writer.WriteEndElement();
}
}
finally
{
state.PopCurrentMemberInfo();
}
}
}
public override void Serialize(object obj, XmlWriter writer, SerializationContext state)
{
try
{
// Start of serialization
state.SerializationStart(obj);
// Serialize attributes
SerializeAttributes(obj, writer, state);
// Serialize elements.
SerializeElements(obj, writer, state);
//Serialize text
SerializeText(obj, writer, state);
}
finally
{
// End of serialization
state.SerializationEnd(obj);
}
}
public override object Deserialize(XmlReader reader, SerializationContext state)
{
return Deserialize(CreateInstance(reader, state), reader, state);
}
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));
}
}
}
}
protected override void SerializeElements(object obj, XmlWriter writer, SerializationContext state)
{
var dicObj = (IDictionary)obj;
foreach (var key in dicObj.Keys)
{
var item = this.primaryDictionaryItem ?? this.typeToItemMap[obj.GetType()];
writer.WriteStartElement(key.ToString());
if (aliasToItemMap.Count > 1)
{
writer.WriteAttributeString("typealias", item.typeAlias);
}
if (item.attribute != null
&& item.attribute.SerializeAsValueNode
&& item.attribute.ValueNodeAttributeName != null
&& item.serializer is TypeSerializerWithSimpleTextSupport)
{
writer.WriteAttributeString(item.attribute.ValueNodeAttributeName, ((TypeSerializerWithSimpleTextSupport)item.serializer).Serialize(dicObj[key], state));
}
else
{
item.serializer.Serialize(dicObj[key], writer, state);
}
writer.WriteEndElement();
}
}
/// <summary> /// /// </summary> /// <param name="reader"></param> /// <param name="state"></param> /// <returns></returns> public abstract object Deserialize(XmlReader reader, SerializationContext state);
