/// <summary>Transforms the specified type into a string that is fit to be traced.</summary> /// <param name="xml">The type to transform.</param> /// <returns>The string.</returns> internal protected static string ToTraceString(IXmlSerializable xml) { var sb=new StringBuilder(); using (var xw=XmlWriter.Create(sb)) xml.WriteXml(xw); return sb.ToString(); }
private static Message CreateMessage(IXmlSerializable response, MessageVersion version) { StringBuilder serialized=new StringBuilder(); using (var xw=XmlWriter.Create(serialized)) response.WriteXml(xw); var xr=XmlReader.Create(new StringReader(serialized.ToString())); return Message.CreateMessage(version, "ExecuteResponse", xr); }
private static void SerializeCustom(XmlWriter writer, XPathResult result, XPathNavigator node, IXmlSerializable value) { if (string.IsNullOrEmpty(node.NamespaceURI)) { writer.WriteStartElement(node.LocalName); } else { var prefix = result.Context.AddNamespace(node.NamespaceURI); writer.WriteStartElement(prefix, node.LocalName, node.NamespaceURI); } value.WriteXml(writer); writer.WriteEndElement(); }
/// <summary> /// Serializes property values to the settings file. /// </summary> /// <param name="filename">The name of the settings file to write to.</param> public void Save(string filename) { // make sure directory exists! Directory.CreateDirectory(Path.GetDirectoryName(filename)); XmlTextWriter w = null; try { w = new XmlTextWriter(filename, System.Text.Encoding.UTF8); w.Formatting = Formatting.Indented; w.WriteStartElement("Settings"); foreach (string key in map.Keys) { object value = map[key]; if (value != null) { if (value is Hashtable) { w.WriteStartElement(key); // container element WriteHashTable(w, (Hashtable)value); w.WriteEndElement(); } else if (value is Array) { WriteArray(w, key, (Array)value); } else if (value is IXmlSerializable) { w.WriteStartElement(key); // container element IXmlSerializable xs = (IXmlSerializable)value; xs.WriteXml(w); w.WriteEndElement(); } else { string s = ConvertToString(value); if (s != null) { w.WriteElementString(key, s); } } } } } catch (Exception e) { Console.WriteLine(e.Message); } finally { using (w) { } } }
public static string WriteXml(IXmlSerializable target) { StringBuilder sb = new StringBuilder(); XmlWriterSettings xmlWriterSettings = new XmlWriterSettings(); xmlWriterSettings.ConformanceLevel = ConformanceLevel.Fragment; using (XmlWriter writer = XmlTextWriter.Create(sb, xmlWriterSettings)) { XmlRootAttribute[] xmlRootAttribute = target.GetType().GetCustomAttributes(typeof(XmlRootAttribute), false) as XmlRootAttribute[]; writer.WriteStartElement(xmlRootAttribute[0].ElementName); target.WriteXml(writer); writer.WriteEndElement(); } return sb.ToString(); }
public void WriteXml(XmlWriter writer) { writer.WriteAttributeString("type", "object"); foreach (KeyValuePair <string, SaveValue> pair in _items) { IXmlSerializable xmlSerializable = pair.Value as IXmlSerializable; if (xmlSerializable != null) { writer.WriteStartElement(pair.Key); xmlSerializable.WriteXml(writer); writer.WriteEndElement(); } } }
public static string WriteXml(IXmlSerializable target) { StringBuilder sb = new StringBuilder(); XmlWriterSettings xmlWriterSettings = new XmlWriterSettings(); xmlWriterSettings.ConformanceLevel = ConformanceLevel.Fragment; using (XmlWriter writer = XmlTextWriter.Create(sb, xmlWriterSettings)) { XmlRootAttribute[] xmlRootAttribute = target.GetType().GetCustomAttributes(typeof(XmlRootAttribute), false) as XmlRootAttribute[]; writer.WriteStartElement(xmlRootAttribute[0].ElementName); target.WriteXml(writer); writer.WriteEndElement(); } return(sb.ToString()); }
public void WriteXml(XmlWriter writer) { writer.WriteAttributeString(DialectAttribute, _dialect); IXmlSerializable serializable = _value as IXmlSerializable; if (serializable != null) { serializable.WriteXml(writer); return; } if (_value != null) { XmlSerializer serializer = new XmlSerializer(_value.GetType()); serializer.Serialize(writer, _value); } }
protected override void OnWriteBodyContents(XmlDictionaryWriter writer) { if (toSerialize != null) { IXmlSerializable serializable = toSerialize as IXmlSerializable; if (serializable != null) { serializable.WriteXml(writer); } else { XmlSerializer xs = new XmlSerializer(toSerialize.GetType()); xs.Serialize(writer, toSerialize); } } }
protected void WriteSerializable(IXmlSerializable serializable, string name, string ns, bool isNullable) { if (serializable == null) { if (isNullable) { WriteNullTagLiteral(name, ns); } return; } else { Writer.WriteStartElement(name, ns); serializable.WriteXml(Writer); Writer.WriteEndElement(); } }
public void ArgumentsTest() { AssertHelper.ExpectedException <ArgumentException>(() => new RecentFile(null !)); var recentFile = new RecentFile("Doc1"); Assert.AreEqual("Doc1", recentFile.Path); AssertHelper.PropertyChangedEvent(recentFile, x => x.IsPinned, () => recentFile.IsPinned = true); Assert.IsTrue(recentFile.IsPinned); IXmlSerializable serializable = recentFile; Assert.IsNull(serializable.GetSchema()); AssertHelper.ExpectedException <ArgumentNullException>(() => serializable.ReadXml(null)); AssertHelper.ExpectedException <ArgumentNullException>(() => serializable.WriteXml(null)); }
private static void SerializeXmlSerializable(IXmlSerializable obj, XContainer parent) { StringBuilder sb = new StringBuilder(); using (XmlWriter xw = XmlWriter.Create(sb, new XmlWriterSettings { ConformanceLevel = ConformanceLevel.Fragment })) { obj.WriteXml(xw); xw.Flush(); } Type objType = obj.GetType(); string contentName = null; object[] attrs = objType.GetCustomAttributes(typeof(XmlRootAttribute), true); if (attrs.Length > 0) { contentName = ((XmlRootAttribute)attrs[0]).ElementName; } if (String.IsNullOrEmpty(contentName)) { contentName = objType.Name; } using (XmlReader xr = XmlReader.Create(new StringReader(sb.ToString()), new XmlReaderSettings { ConformanceLevel = ConformanceLevel.Fragment, CloseInput = true })) { if (!xr.Read()) { return; } XElement content = new XElement(contentName); while (!xr.EOF) { content.Add(XNode.ReadFrom(xr)); } parent.Add(content); } parent.Add(new XAttribute(XmlSerializer.AttributeFormat, XmlSerializer.AttributeValueCustom)); }
public void WriteXml(XmlWriter writer) { writer.WriteStartElement(this.GetType().ToString()); writer.WriteAttributeString("assembly", CurrentAssemblyName); writer.WriteAttributeString("title", title.Text); writer.WriteAttributeString("Expand", Expand.ToString()); writer.WriteStartElement("widget"); IXmlSerializable xmlitm = CurrentWidget as IXmlSerializable; if (xmlitm != null) { xmlitm.WriteXml(writer); } writer.WriteEndElement(); writer.WriteEndElement(); }
public void WriteXml(XmlWriter writer) { writer.WriteAttributeString("type", "array"); int curIndex = 0; foreach (SaveValue item in _items) { IXmlSerializable xmlSerializable = item as IXmlSerializable; if (xmlSerializable != null) { writer.WriteStartElement("Item"); writer.WriteAttributeString("index", curIndex.ToString()); xmlSerializable.WriteXml(writer); writer.WriteEndElement(); curIndex++; } } }
/// <include file='doc\XmlSerializationWriter.uex' path='docs/doc[@for="XmlSerializationWriter.WriteSerializable1"]/*' /> protected void WriteSerializable(IXmlSerializable serializable, string name, string ns, bool isNullable, bool wrapped) { if (serializable == null) { if (isNullable) { WriteNullTagLiteral(name, ns); } return; } if (wrapped) { _w.WriteStartElement(name, ns); } serializable.WriteXml(_w); if (wrapped) { _w.WriteEndElement(); } }
/// <summary> /// Serialize to XML string /// </summary> /// <param name="o">object to be serialized</param> /// <returns>json string of object</returns> public static string SerializeToXML(IXmlSerializable apiObject) { XmlWriterSettings settings = new XmlWriterSettings(); settings.ConformanceLevel = ConformanceLevel.Fragment; settings.CloseOutput = false; var ms = new StringBuilder(); { using (XmlWriter writer = XmlWriter.Create(ms, settings)) { //Write to XML first (built into ESAPI) var @class = apiObject.GetType().FullName; writer.WriteStartElement(@class); apiObject.WriteXml(writer); writer.WriteFullEndElement(); writer.Close(); var xml = ms.ToString(); return(xml); } } }
private bool CheckExceptions(IXmlSerializable instance) { try { // ReSharper disable ReturnValueOfPureMethodIsNotUsed instance.GetSchema(); // ReSharper restore ReturnValueOfPureMethodIsNotUsed throw new UnitTestException(string.Format(CultureInfo.InvariantCulture, Resources.XmlSerialization_GetSchema, Type.Name)); } catch (NotSupportedException) { } try { // ReSharper disable ReturnValueOfPureMethodIsNotUsed instance.ReadXml(null); // ReSharper restore ReturnValueOfPureMethodIsNotUsed throw new UnitTestException(string.Format(CultureInfo.InvariantCulture, Resources.XmlSerialization_ReadXmlNull, Type.Name)); } catch (ArgumentNullException) { } try { // ReSharper disable ReturnValueOfPureMethodIsNotUsed instance.WriteXml(null); // ReSharper restore ReturnValueOfPureMethodIsNotUsed throw new UnitTestException(string.Format(CultureInfo.InvariantCulture, Resources.XmlSerialization_WriteXmlNull, Type.Name)); } catch (ArgumentNullException) { } return(true); }
/// <summary> /// Writer must be in parent element, which should be closed by the parent. /// </summary> private static void SerializeXmlSerializable(IXmlSerializable obj, XmlWriter writer) { writer.WriteAttributeString(XmlSerializer.AttributeFormat, XmlSerializer.AttributeValueCustom); Type objType = obj.GetType(); string contentName = null; object[] attrs = objType.GetCustomAttributes(typeof(XmlRootAttribute), true); if (attrs.Length > 0) { contentName = ((XmlRootAttribute)attrs[0]).ElementName; } if (String.IsNullOrEmpty(contentName)) { contentName = objType.Name; } writer.WriteStartElement(contentName); obj.WriteXml(writer); writer.WriteFullEndElement(); }
public void WriteXml(XmlWriter writer) { writer.WriteStartElement("triple"); writer.WriteAttributeString("type", this.GetType().ToString()); if (!this.isDefaultGraph) { if (this.variableDataSet != null) { writer.WriteAttributeString("graph", "variable"); this.variableDataSet.WriteXml(writer); } else { writer.WriteAttributeString("graph", "named"); this.graphs.WriteXml(writer); } } else { writer.WriteAttributeString("graph", "default"); } IXmlSerializable s = this.sVariableNode ?? this.Subject; s.WriteXml(writer); IXmlSerializable p = this.pVariableNode ?? this.Predicate; p.WriteXml(writer); IXmlSerializable o = this.oVariableNode ?? this.Object; o.WriteXml(writer); writer.WriteEndElement(); }
public void XmlSerializing() { XmlSerializer serializer = new XmlSerializer(typeof(RecentFileList)); // Serialize an empty list MemoryStream stream1 = new MemoryStream(); RecentFileList recentFileList1 = new RecentFileList(); serializer.Serialize(stream1, recentFileList1); stream1.Position = 0; RecentFileList recentFileList2 = (RecentFileList)serializer.Deserialize(stream1); Assert.AreEqual(recentFileList1.RecentFiles.Count, recentFileList2.RecentFiles.Count); AssertHelper.SequenceEqual(recentFileList1.RecentFiles.Select(f => f.Path), recentFileList2.RecentFiles.Select(f => f.Path)); // Serialize a list with items MemoryStream stream2 = new MemoryStream(); recentFileList2.AddFile("Doc3"); recentFileList2.AddFile("Doc2"); recentFileList2.AddFile("Doc1"); serializer.Serialize(stream2, recentFileList2); stream2.Position = 0; RecentFileList recentFileList3 = (RecentFileList)serializer.Deserialize(stream2); AssertHelper.SequenceEqual(recentFileList2.RecentFiles.Select(f => f.Path), recentFileList3.RecentFiles.Select(f => f.Path)); // Set MaxFilesNumber to a lower number recentFileList3.MaxFilesNumber = 2; AssertHelper.SequenceEqual(new[] { "Doc1", "Doc2" }, recentFileList3.RecentFiles.Select(f => f.Path)); // Check error handling of the serializable implementation IXmlSerializable serializable = recentFileList3; Assert.IsNull(serializable.GetSchema()); AssertHelper.ExpectedException <ArgumentNullException>(() => serializable.ReadXml(null)); AssertHelper.ExpectedException <ArgumentNullException>(() => serializable.WriteXml(null)); }
void WriteSerializable(IXmlSerializable serializable, string name, string ns, bool isNullable, bool wrapped) { if (serializable == null) { if (isNullable && wrapped) { WriteNullTagLiteral(name, ns); } return; } else { if (wrapped) { Writer.WriteStartElement(name, ns); } serializable.WriteXml(Writer); if (wrapped) { Writer.WriteEndElement(); } } }
/// <summary> /// Helper method for serializing a simple or complex type and /// formating the data into an xml element. /// </summary> /// <param name="name"></param> /// <param name="obj"></param> /// <returns></returns> protected XmlElement SerializeCore(string name, object obj) { //if we are serializing a null object, we have already created the element for it //so now we need to let it know there is no data to be found. if (IsReferenceNull(obj)) { XmlElement e = Doc.CreateElement(name); e.SetAttribute("value", "null"); return(e); } //we want Unity objects to be identified by their type Type objType = obj.GetType(); XmlElement element = null; if (obj is UnityEngine.Object && name == null) { element = Doc.CreateElement(objType.Name); } else { element = Doc.CreateElement(name); } //WARNING: I'm guessing 'AnsiClass' means 'struct'. Not entirely sure though. //And I have no idea what an 'AutoClass' or 'UnicodeClass' is at all. //we are serializing a complex object of some kind if (objType.IsClass && objType != typeof(string)) { //This object is a Unity component that had its serialization previously defered. //We now need to know what that defered element used as an id and store that //when we serialize this object. if (DeferedCache != null && DeferedCache.ContainsKey(obj)) { element.SetAttribute("id", GetCacheId(objType, obj).ToString()); //element.SetAttribute("DeferedId", DeferedCache[obj].ToString()); //tj //SetAsDeferedComponent((Component)obj, element); //continue serialization as normal from here... } //if this is not a unity object we still need to check the object cache and see //if we already serialized it once. else if (Options.UseGraphSerialization && !AddObjToCache(objType, obj, element)) { return(element); } // the object has just been added SetTypeInfo(objType, element); //TODO: For general-surrogate support we'll need to implement it here. if (CheckForcedSerialization(objType)) { // serialize as complex type SerializeComplexType(obj, ref element); return(element); } IXmlSerializable xmlSer = obj as IXmlSerializable; if (xmlSer == null) { //HACK ALERT: Hard-coding logic tied to specific datatypes!! //We need to intercept Unity built-in types here because some of //them expose the IEnumerable interface and will cause inifite loops //(namely, the Transform component). if (objType.IsSubclassOf(typeof(Component))) { SerializeComplexType(obj as Component, ref element); return(element); } // does not know about automatic serialization IEnumerable enumerable = obj as IEnumerable; if (enumerable == null) { SerializeComplexType(obj, ref element); } else { //This gets a little poo-poo here. We can't simply serialize //as a list of enumerables if this is a multi-dimensional array //since we'll need to know the individual ranks and rank lengths //when we deserialize. So we'll try casting to see what we do next. var arr = obj as Array; if (arr != null && arr.Rank > 1) { element.SetAttribute("Ranks", ArrayRankCounter(arr)); SerializeMultiDimensionalArray(name, arr, 0, new int[arr.Rank], element); } else { //either a single-dimensional array or just an enumerable list of some kind foreach (object arrObj in enumerable) { XmlElement e = SerializeCore(name, arrObj); element.AppendChild(e); } } } } else { // can perform the serialization itself StringBuilder sb = new StringBuilder(); XmlWriterSettings settings = new XmlWriterSettings(); settings.ConformanceLevel = ConformanceLevel.Fragment; settings.Encoding = Encoding.UTF8; settings.OmitXmlDeclaration = true; XmlWriter wr = XmlWriter.Create(sb, settings); wr.WriteStartElement("value"); xmlSer.WriteXml(wr); wr.WriteEndElement(); wr.Close(); element.InnerXml = sb.ToString(); } } else { // the object has just been added SetTypeInfo(objType, element); if (CheckForcedSerialization(objType)) { // serialize as complex type SerializeComplexType(obj, ref element); return(element); } if (objType.IsEnum) { object val = Enum.Format(objType, obj, "d"); element.SetAttribute("value", val.ToString()); } else { if (objType.IsPrimitive || objType == typeof(string) || objType == typeof(DateTime) || objType == typeof(decimal)) { element.SetAttribute("value", obj.ToString()); } else { // this is most probably a struct (or autoclass or unicodeclass, whatever those are) SerializeComplexType(obj, ref element); } } } return(element); }
public static void WriteElement(this XmlWriter writer, string name, IXmlSerializable child) { writer.WriteStartElement(name); child.WriteXml(writer); writer.WriteEndElement(); }
/// <summary> /// Writes an element /// </summary> /// <param name="writer">An Xml Writer</param> /// <param name="name">The element name</param> /// <param name="value">The value</param> internal static void WriteElement(this XmlWriter writer, string name, IXmlSerializable value) { writer.WriteStartElement(name); value.WriteXml(writer); writer.WriteEndElement(); }
/// <include file='doc\XmlSerializationWriter.uex' path='docs/doc[@for="XmlSerializationWriter.WriteSerializable1"]/*' /> protected void WriteSerializable(IXmlSerializable serializable, string name, string ns, bool isNullable, bool wrapped) { if (serializable == null) { if (isNullable) WriteNullTagLiteral(name, ns); return; } if (wrapped) { w.WriteStartElement(name, ns); } serializable.WriteXml(w); if (wrapped) { w.WriteEndElement(); } }
public void Serialize(IXmlSerializable item, XmlWriter output) { if (item == null) throw new ArgumentNullException("value"); if (output == null) throw new ArgumentNullException("output"); XmlRootAttribute xmlRootAttr = GetXmlRootAttribute(item.GetType()); XmlRootPrefixedAttribute xmlRootPrefixAttr = xmlRootAttr as XmlRootPrefixedAttribute; if (xmlRootPrefixAttr != null && xmlRootPrefixAttr.Prefix.HasValue()) { output.WriteStartElement(xmlRootPrefixAttr.Prefix, xmlRootAttr.ElementName, xmlRootAttr.Namespace); } else { output.WriteStartElement(xmlRootAttr.ElementName, xmlRootAttr.Namespace); } item.WriteXml(output); output.WriteEndElement(); }
XmlElement SerializeCore(string name, object obj) { if (name.Contains("<") || name.Contains(">")) { name = name.Replace("<", string.Empty).Replace(">k__BackingField", string.Empty); } XmlElement element = doc.CreateElement(name); if (obj == null) { element.SetAttribute("value", "null"); return(element); } Type objType = obj.GetType(); if (objType.IsClass && objType != typeof(string)) { // check if we have already serialized this object if (options.UseGraphSerialization && !AddObjToCache(objType, obj, element)) { return(element); } // the object has just been added SetTypeInfo(objType, element); if (CheckForcedSerialization(objType)) { // serialize as complex type SerializeComplexType(obj, element); return(element); } IXmlSerializable xmlSer = obj as IXmlSerializable; if (xmlSer == null) { // does not know about automatic serialization IEnumerable arr = obj as IEnumerable; if (arr == null) { SerializeComplexType(obj, element); } else { foreach (object arrObj in arr) { XmlElement e = SerializeCore(name, arrObj); element.AppendChild(e); } } } else { // can perform the serialization itself StringBuilder sb = new StringBuilder(); XmlWriterSettings settings = new XmlWriterSettings(); settings.ConformanceLevel = ConformanceLevel.Fragment; settings.Encoding = Encoding.UTF8; settings.OmitXmlDeclaration = true; XmlWriter wr = XmlWriter.Create(sb, settings); wr.WriteStartElement("value"); xmlSer.WriteXml(wr); wr.WriteEndElement(); wr.Close(); element.InnerXml = sb.ToString(); } } else { // the object has just been added SetTypeInfo(objType, element); if (CheckForcedSerialization(objType)) { // serialize as complex type SerializeComplexType(obj, element); return(element); } if (objType.IsEnum) { object val = Enum.Format(objType, obj, "d"); element.SetAttribute("value", val.ToString()); } else { if (objType.IsPrimitive || objType == typeof(string) || objType == typeof(DateTime) || objType == typeof(decimal)) { element.SetAttribute("value", obj.ToString()); } else { // this is most probably a struct SerializeComplexType(obj, element); } } } return(element); }
private bool CheckExceptions(IXmlSerializable instance) { try { // ReSharper disable ReturnValueOfPureMethodIsNotUsed instance.GetSchema(); // ReSharper restore ReturnValueOfPureMethodIsNotUsed throw new UnitTestException(string.Format(CultureInfo.InvariantCulture, Resources.XmlSerialization_GetSchema, Type.Name)); } catch (NotSupportedException) { } try { // ReSharper disable ReturnValueOfPureMethodIsNotUsed instance.ReadXml(null); // ReSharper restore ReturnValueOfPureMethodIsNotUsed throw new UnitTestException(string.Format(CultureInfo.InvariantCulture, Resources.XmlSerialization_ReadXmlNull, Type.Name)); } catch (ArgumentNullException) { } try { // ReSharper disable ReturnValueOfPureMethodIsNotUsed instance.WriteXml(null); // ReSharper restore ReturnValueOfPureMethodIsNotUsed throw new UnitTestException(string.Format(CultureInfo.InvariantCulture, Resources.XmlSerialization_WriteXmlNull, Type.Name)); } catch (ArgumentNullException) { } return true; }
public void WriteXml(XmlWriter w) { w.WriteStartDocument(); w.WriteStartElement("Settings"); ArrayList keys = new ArrayList(map.Keys); keys.Sort(); foreach (string key in keys) { object value = map[key]; if (value == null) { continue; } PropertyInfo pi = this.GetType().GetProperty(key); if (pi != null) { Type t = pi.PropertyType; if (t == typeof(Point)) { w.WriteStartElement(key); SerializePoint(w, (Point)value); w.WriteEndElement(); } else if (t == typeof(Size)) { SerializeSize(w, key, (Size)value); } else if (t == typeof(int)) { w.WriteElementString(key, ((int)value).ToString()); } else if (t == typeof(string)) { w.WriteElementString(key, ((string)value)); } else if (t == typeof(GraphState)) { w.WriteStartElement(key); this.GraphState.WriteXml(w); w.WriteEndElement(); } else if (t == typeof(DateTime)) { SerializeDateTime(w, key, (DateTime)value); } else if (t == typeof(TimeSpan)) { SerializeTimeSpan(w, key, (TimeSpan)value); } else if (t == typeof(bool)) { w.WriteElementString(key, ((bool)value).ToString()); } else if (t == typeof(QueryRow[])) { w.WriteStartElement(key); WriteQuery(w, (QueryRow[])value); w.WriteEndElement(); } else { throw new Exception("Settings.ReadXml encountered unsupported property type '" + t.FullName + "'"); } } else if (value is IXmlSerializable) { IXmlSerializable s = (IXmlSerializable)value; if (s != null) { w.WriteStartElement(key); s.WriteXml(w); w.WriteEndElement(); } } else { w.WriteElementString(key, value.ToString()); } } HashSet <Type> saved = new HashSet <Type>(); foreach (KeyValuePair <Type, ViewState> pair in this.viewStates) { Type t = pair.Key; ViewState s = pair.Value; if (s != null) { saved.Add(t); string key = s.GetType().FullName; w.WriteStartElement(key); w.WriteAttributeString("ViewType", t.FullName); s.WriteXml(w); w.WriteEndElement(); } } foreach (KeyValuePair <Type, XmlElement> pair in this.viewStateNodes) { Type t = pair.Key; if (!saved.Contains(t)) { // this view type was not used, but we need to round trip the previous settings so we don't lose them. XmlElement e = pair.Value; if (e != null) { e.WriteTo(w); } } } w.WriteEndElement(); w.WriteEndDocument(); }
XmlElement SerializeCore(string name, object obj, Type objType, string elementType) { XmlElement element = doc.CreateElement(elementType); element.SetAttribute("Name", name); if (obj == null) { element.SetAttribute("value", NULL_VALUE); return(element); } if (objType.IsClass && objType != typeof(string)) { // check if we have already serialized this object if (options.UseGraphSerialization && !AddObjToCache(objType, obj, element)) { return(element); } // the object has just been added SetTypeInfo(objType, element); if (CheckForcedSerialization(objType)) { // serialize as complex type SerializeComplexType(obj, objType, element); return(element); } IXmlSerializable xmlSer = obj as IXmlSerializable; if (xmlSer == null) { // does not know about automatic serialization if (objType.IsSubclassOf(typeof(XmlNode))) { SerializeXmlType(obj, objType, element); } else { IEnumerable arr = obj as IEnumerable; if (arr == null) { SerializeComplexType(obj, objType, element); } else { SerializeIEnumerable(name, arr, element); } } } else { // can perform the serialization itself StringBuilder sb = new StringBuilder(); XmlWriterSettings settings = new XmlWriterSettings(); settings.ConformanceLevel = ConformanceLevel.Fragment; settings.Encoding = Encoding.UTF8; settings.OmitXmlDeclaration = true; XmlWriter wr = XmlWriter.Create(sb, settings); wr.WriteStartElement("value"); xmlSer.WriteXml(wr); wr.WriteEndElement(); wr.Close(); element.InnerXml = sb.ToString(); } } else { // the object has just been added SetTypeInfo(objType, element); if (CheckForcedSerialization(objType)) { // serialize as complex type SerializeComplexType(obj, objType, element); return(element); } if (objType.IsEnum) { object val = Enum.Format(objType, obj, "d"); element.SetAttribute("value", val.ToString()); } else { if (objType.IsPrimitive || objType == typeof(string) || objType == typeof(DateTime) || objType == typeof(decimal)) { element.SetAttribute("value", obj.ToString()); } else { // this is most probably a struct SerializeComplexType(obj, objType, element); } } } return(element); }
void WriteSerializable (IXmlSerializable serializable, string name, string ns, bool isNullable, bool wrapped) { if (serializable == null) { if (isNullable && wrapped) WriteNullTagLiteral (name, ns); return; } else { if (wrapped) Writer.WriteStartElement (name, ns); serializable.WriteXml (Writer); if (wrapped) Writer.WriteEndElement (); } }
/// <summary/> public void Serialize(XmlTextWriter writer, object obj, bool writeElement) { //Use the IXmlSerializable implementation if needed IXmlSerializable serializableObject = obj as IXmlSerializable; if (serializableObject != null) { serializableObject.WriteXml(writer); return; } //If the type can be converted directly to a string then serialize it //as an element with text content (int, string, etc) TypeConverter conv = TypeDescriptor.GetConverter(obj); if (CanSerialize(conv)) { writer.WriteElementString(obj.GetType().Name.ToUpperInvariant(), conv.ConvertToInvariantString(obj)); return; } //Serialize the object and its public members if (writeElement) { writer.WriteStartElement(obj.GetType().Name); } //Get the list of properties with the ones that want to be serialized as attributed listed first List <PropertyDescriptor> props = SortAttributedProperties(obj); //Serialize the Properties foreach (PropertyDescriptor prop in props) { //Get the property value object value = prop.GetValue(obj); if (value == null) { continue; } if (prop.IsReadOnly) { //if the property is read-only and is a list then serialize the content IList list = value as IList; if (list != null && list.Count > 0) { writer.WriteStartElement(prop.Name); string elementName = prop.Name.Substring(0, prop.Name.Length - 1); DefaultListSerializer serializer = new DefaultListSerializer(elementName); serializer.Serialize(writer, list, false); writer.WriteEndElement(); } } else { //Get a converter and Serialize it to a string TypeConverter converter = prop.Converter; if (converter == null || !converter.CanConvertTo(typeof(string)) || !converter.CanConvertFrom(typeof(string))) { writer.WriteStartElement(prop.Name); ObjectSerializer.Serialize(writer, value, false); writer.WriteEndElement(); continue; } string strValue = converter.ConvertToString(null, InvariantSerializationCulture, value); if (prop.Attributes.Contains(new XmlAttributeAttribute())) { writer.WriteAttributeString(prop.Name, strValue); } else { writer.WriteElementString(prop.Name, strValue); } } } if (writeElement) { writer.WriteEndElement(); //Object element } }
private static string WriteXml(IXmlSerializable obj) { var f = Path.GetTempFileName(); //var f = "test.xml"; using (var writer = GetXmlWriter(f)) { writer.WriteStartElement("root"); obj.WriteXml(writer); writer.WriteEndElement(); } return f; }
/// <summary> /// Converts or casts an object to a string. /// </summary> /// <param name="obj">The string to cast / convert.</param> /// <param name="handleDBNullAsNull"> /// Handle <see cref="DBNull" /> objects as <see langword="null" /> or not. /// </param> /// <returns>The converted / casted string.</returns> /// <remarks> /// If <paramref name="obj" /> is <see langword="null" /> the result will also be <see langword="null" />. /// If <paramref name="obj" /> is already a <see cref="string" />, it is simply casted. /// </remarks> public static string AsString(object obj, bool handleDBNullAsNull) { if (obj == null) { return(null); } if (obj is string) { return((string)obj); } if (handleDBNullAsNull && DBNull.Value.Equals(obj)) { return(null); } if (obj is IEnumerable <char> ) { // char sequence / array return(new string(CollectionHelper.AsArray(obj as IEnumerable <char>))); } else if (obj is TextReader) { // read text to end return(((TextReader)obj).ReadToEnd()); } else if (obj is IEnumerable <byte> ) { // hex string return(AsHexString(obj as IEnumerable <byte>, true)); } else if (obj is Stream) { // handle blob as UTF-8 string data using (StreamReader reader = new StreamReader(new NonDisposableStream(obj as Stream), Encoding.UTF8)) { return(AsString(reader, true)); } } else if (obj is IXmlSerializable) { // XML object IXmlSerializable xmlObj = (IXmlSerializable)obj; StringBuilder xml = new StringBuilder(); using (StringWriter strWriter = new StringWriter(xml)) { using (XmlWriter xmlWriter = XmlWriter.Create(strWriter)) { xmlObj.WriteXml(xmlWriter); xmlWriter.Flush(); xmlWriter.Close(); } } return(AsString(xml, true)); } else if (obj is IContentProvider) { IContentProvider provider = (IContentProvider)obj; Stream stream = provider.OpenStream(); if (stream != null) { using (StreamReader reader = new StreamReader(stream, provider.Encoding ?? Encoding.UTF8, false)) { return(AsString(reader, true)); } } return(null); } else if ((obj is IEnumerable <string>) || (obj is IEnumerable <IEnumerable <char> >)) { // concat string sequence IEnumerable seq = (IEnumerable)obj; IEnumerable <object> objSeq = CollectionHelper.Cast <object>(seq); StringBuilder concatedStrList = new StringBuilder(); foreach (object item in objSeq) { concatedStrList.Append(AsString(item, true)); } return(concatedStrList.ToString()); } bool extensionHandled = false; StringBuilder extensionResultBuilder = new StringBuilder(); AsStringExtension(obj, ref extensionHandled, ref extensionResultBuilder); if (extensionHandled) { return(extensionResultBuilder != null?extensionResultBuilder.ToString() : null); } // use default return(obj.ToString()); }
public void WriteXml(XmlWriter writer) { serializer.WriteXml(writer, this); }
void IXmlSerializable.WriteXml(XmlWriter writer) { IXmlSerializable serializable = this.Untyped as IXmlSerializable; serializable.WriteXml(writer); }
private XmlElement SerializeCore(string name, object obj) { XmlElement xmlElement = this.doc.CreateElement(name); if (obj == null) { xmlElement.SetAttribute("value", "null"); return(xmlElement); } Type type = obj.GetType(); if (type.IsClass && type != typeof(string)) { if (this.options.UseGraphSerialization && !this.AddObjToCache(type, obj, xmlElement)) { return(xmlElement); } this.SetTypeInfo(type, xmlElement); if (CustomXmlSerializer.CheckForcedSerialization(type)) { this.SerializeComplexType(obj, xmlElement); return(xmlElement); } IXmlSerializable xmlSerializable = obj as IXmlSerializable; if (xmlSerializable == null) { IEnumerable enumerable = obj as IEnumerable; if (enumerable == null) { this.SerializeComplexType(obj, xmlElement); return(xmlElement); } IEnumerator enumerator = enumerable.GetEnumerator(); try { while (enumerator.MoveNext()) { object current = enumerator.Current; XmlElement newChild = this.SerializeCore(name, current); xmlElement.AppendChild(newChild); } return(xmlElement); } finally { IDisposable disposable = enumerator as IDisposable; if (disposable != null) { disposable.Dispose(); } } } StringBuilder stringBuilder = new StringBuilder(); XmlWriter xmlWriter = XmlWriter.Create(stringBuilder, new XmlWriterSettings { ConformanceLevel = ConformanceLevel.Fragment, Encoding = Encoding.UTF8, OmitXmlDeclaration = true }); xmlWriter.WriteStartElement("value"); xmlSerializable.WriteXml(xmlWriter); xmlWriter.WriteEndElement(); xmlWriter.Close(); xmlElement.InnerXml = stringBuilder.ToString(); } else { this.SetTypeInfo(type, xmlElement); if (CustomXmlSerializer.CheckForcedSerialization(type)) { this.SerializeComplexType(obj, xmlElement); return(xmlElement); } if (type.IsEnum) { object obj2 = Enum.Format(type, obj, "d"); xmlElement.SetAttribute("value", obj2.ToString()); } else { if (type.IsPrimitive || type == typeof(string) || type == typeof(DateTime) || type == typeof(decimal)) { xmlElement.SetAttribute("value", obj.ToString()); } else { this.SerializeComplexType(obj, xmlElement); } } } return(xmlElement); }
protected void WriteSerializable (IXmlSerializable serializable, string name, string ns, bool isNullable) { if (serializable == null) { if (isNullable) WriteNullTagLiteral (name, ns); return; } else { Writer.WriteStartElement (name, ns); serializable.WriteXml (Writer); Writer.WriteEndElement (); } }
/// <summary> /// Attach an <see cref="IXmlSerializable"/> to an XML file. /// </summary> public static void SerializeObject(XmlWriter writer, IXmlSerializable target) { writer.WriteStartElement(target.GetType().Name); target.WriteXml(writer); writer.WriteEndElement(); }