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);