protected IXmlSerializable ReadSerializable(IXmlSerializable serializable, bool wrappedAny) { string name = null; string ns = null; if (wrappedAny) { name = reader.LocalName; ns = reader.NamespaceURI; reader.Read(); reader.MoveToContent(); } serializable.ReadXml(reader); if (wrappedAny) { while (reader.NodeType == XmlNodeType.Whitespace) { reader.Skip(); } if (reader.NodeType == XmlNodeType.None) { reader.Skip(); } if (reader.NodeType == XmlNodeType.EndElement && reader.LocalName == name && reader.NamespaceURI == ns) { reader.Read(); } } return(serializable); }
/// <summary> /// deep copy an object using XmlSerialization /// </summary> /// <param name="elementName">name of surrounding element when writing the object</param> /// <param name="source">object to copy</param> /// <param name="destination">new blank element to copy into</param> public static void CloneUsingXmlSerialization(string elementName, IXmlSerializable source, IXmlSerializable destination) { XmlWriterSettings writeSettings = new XmlWriterSettings { OmitXmlDeclaration = true, ConformanceLevel = ConformanceLevel.Fragment, CloseOutput = false, Encoding = Encoding.UTF8 }; MemoryStream memoryStream = new MemoryStream(); var xmlWriter = XmlWriter.Create(memoryStream, writeSettings); // simulate the behaviour of XmlSerialisation xmlWriter.WriteStartElement(elementName); source.WriteXml(xmlWriter); xmlWriter.WriteEndElement(); xmlWriter.Flush(); memoryStream.Position = 0; XmlReaderSettings readSettings = new XmlReaderSettings { ConformanceLevel = ConformanceLevel.Fragment }; var reader = XmlReader.Create(memoryStream, readSettings); destination.ReadXml(reader); }
public static IXmlSerializable CreateByTypeAttribute(XmlReader reader) { reader.ReadStartElement(); if (!reader.IsStartElement()) { return(null); } //reader.ReadStartElement(); // reader.MoveToAttribute("type"); // if (!reader.ReadAttributeValue()) { } string typeString = reader.GetAttribute("type"); if (typeString == null) { throw new NullReferenceException(); } else { Type type = Type.GetType(typeString); IXmlSerializable obj = (IXmlSerializable)type.GetConstructor(new Type[0]).Invoke(new object[0]); obj.ReadXml(reader); if (!reader.IsEmptyElement) { reader.ReadEndElement(); } //reader.Skip(); return(obj); } }
public void ReadXml(XmlReader reader) { _dialect = reader.GetAttribute(DialectAttribute); Type type = FilterMapExtension.GetDialectType(_dialect); if (type == null) { throw CreateNotSupportedDialectException(); } if (type == typeof(void)) { return; } if (typeof(IXmlSerializable).IsAssignableFrom(type)) { IXmlSerializable serializable = (IXmlSerializable)Activator.CreateInstance(type); serializable.ReadXml(reader); return; } XmlSerializer serializer = new XmlSerializer(type); if (!reader.IsEmptyElement) { reader.ReadStartElement("Filter", reader.NamespaceURI); _value = serializer.Deserialize(reader); reader.ReadEndElement(); } }
/// <summary> /// Deserialize xml string to object. /// </summary> /// <param name="data">Deserialized string</param> /// <param name="obj">The object implements IXmlSerializable.</param> public static void Deserialize(string data, IXmlSerializable obj) { if (data.Equals(string.Empty)) { return; } XmlReader reader = null; StringReader sr = null; try { sr = new StringReader(data); reader = new XmlTextReader(sr); obj.ReadXml(reader); } catch { } finally { if (sr != null) { sr.Close(); } } }
public void ReadXml(XmlReader reader) { if (reader.IsEmptyElement) { reader.Read(); return; } reader.ReadStartElement(); while (reader.NodeType != XmlNodeType.EndElement) { string key = reader.LocalName; string type = reader.GetAttribute("type"); SaveValue saveValue = SaveValue.Instantiate(type); IXmlSerializable xmlSerializable = saveValue as IXmlSerializable; if (xmlSerializable != null) { xmlSerializable.ReadXml(reader); _items[key] = saveValue; } if (reader.EOF) { throw new IOException("Malformed XML file"); } } reader.ReadEndElement(); }
public override void SetXmlInstance(object inst, XamlMember property, XData xData) { IXmlSerializable serializable = this.GetValue(inst, property, true) as IXmlSerializable; if (serializable == null) { throw this.CreateException(System.Xaml.SR.Get("XmlDataNull", new object[] { property.Name })); } XmlReader xmlReader = xData.XmlReader as XmlReader; if (xmlReader == null) { throw new XamlInternalException(System.Xaml.SR.Get("XmlValueNotReader", new object[] { property.Name })); } try { serializable.ReadXml(xmlReader); } catch (Exception exception) { if (CriticalExceptions.IsCriticalException(exception)) { throw; } throw this.CreateException(System.Xaml.SR.Get("SetXmlInstance", new object[] { property }), exception); } }
/// <summary> /// Deserialize xml file to object. /// </summary> /// <param name="obj">The object implements IXmlSerializable.</param> /// <param name="fileName">The name of file used to stored object.</param> public static void Deserialize(IXmlSerializable obj, string fileName) { if (!File.Exists(fileName)) { return; } FileStream fs = null; XmlReader reader = null; try { fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read); reader = new XmlTextReader(fs); obj.ReadXml(reader); } catch { } finally { //Throw if (fs != null) { fs.Close(); } } }
public static void ReadElement(XmlReader reader, string localName, IXmlSerializable instance) { if (reader.IsStartElement(localName)) { instance.ReadXml(reader); } }
internal static object ReadIXmlSerializable(XmlSerializableReader xmlSerializableReader, XmlReaderDelegator xmlReader, XmlDataContract xmlDataContract, bool isMemberType) { object obj = null; xmlSerializableReader.BeginRead(xmlReader); if (isMemberType && !xmlDataContract.HasRoot) { xmlReader.Read(); xmlReader.MoveToContent(); } if (xmlDataContract.UnderlyingType == Globals.TypeOfXmlElement) { if (!xmlReader.IsStartElement()) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateUnexpectedStateException(XmlNodeType.Element, xmlReader)); } XmlDocument xmlDoc = new XmlDocument(); obj = (XmlElement)xmlDoc.ReadNode(xmlSerializableReader); } else if (xmlDataContract.UnderlyingType == Globals.TypeOfXmlNodeArray) { obj = XmlSerializableServices.ReadNodes(xmlSerializableReader); } else { IXmlSerializable xmlSerializable = xmlDataContract.CreateXmlSerializableDelegate(); xmlSerializable.ReadXml(xmlSerializableReader); obj = xmlSerializable; } xmlSerializableReader.EndRead(); return(obj); }
public void ReadXmlTest() { var recentFileList = new RecentFileList(); IXmlSerializable serializable = recentFileList; serializable.ReadXml(null); }
public void ReadXml(XmlReader reader) { if (reader.IsEmptyElement) { reader.Read(); return; } reader.ReadStartElement(); while (reader.NodeType != XmlNodeType.EndElement) { string type = reader.GetAttribute("type"); SaveValue saveValue = SaveValue.Instantiate(type); IXmlSerializable xmlSerializable = saveValue as IXmlSerializable; if (xmlSerializable != null) { xmlSerializable.ReadXml(reader); _items.Add(saveValue); } } reader.ReadEndElement(); }
// SetXmlInstance: receives the value as "object" so the calling code doesn't // need to load System.Xml.dll types to make the call. public override void SetXmlInstance(object inst, XamlMember property, XAML3.XData xData) { object propInstance = GetValue(inst, property, true); IXmlSerializable iXmlSerial = propInstance as IXmlSerializable; if (iXmlSerial == null) { throw CreateException((SR.Get(SRID.XmlDataNull, property.Name))); } XmlReader reader = xData.XmlReader as XmlReader; if (reader == null) { throw new XamlInternalException(SR.Get(SRID.XmlValueNotReader, property.Name)); } try { iXmlSerial.ReadXml(reader); } catch (Exception e) { if (CriticalExceptions.IsCriticalException(e)) { throw; } throw CreateException(SR.Get(SRID.SetXmlInstance, property), e); } }
private static void SetXmlContent(IXmlSerializable serializable, string content) { if (content == null) { content = string.Empty; } serializable.ReadXml(XmlReader.Create(new StringReader(content))); }
/// <summary> /// Reads a library subset description object from an XML fragment. /// </summary> /// <param name="fragment">The XML reader containing the fragment to read.</param> /// <returns>The parsed LSLLibrarySubsetDescription object.</returns> public static LSLLibrarySubsetDescription FromXmlFragment(XmlReader fragment) { var ev = new LSLLibrarySubsetDescription(); IXmlSerializable x = ev; x.ReadXml(fragment); return(ev); }
private static void ReadXmlSerializable(DataTable dt, XmlReader xr) { XmlSerializer serializer = new XmlSerializer(dt.GetType()); IXmlSerializable idt = dt; idt.ReadXml(xr); xr.Close(); }
public void ReadXmlTest_Precondition() { var recentFile = new RecentFile("Doc1"); IXmlSerializable serializable = recentFile; serializable.ReadXml(null); }
/// <summary> /// Loads the specified settings file and deserializes values. It uses the existing /// settings to figure out the type to convert the strings to. /// </summary> /// <param name="filename">XmlNotepad settings xml file.</param> public void Load(string filename) { // we don't use the serializer because it's too slow to fire up. XmlTextReader r = null; try { r = new XmlTextReader(filename); if (r.IsStartElement("Settings")) { while (r.Read()) { if (r.NodeType == XmlNodeType.Element) { string name = r.Name; object o = map[name]; if (o != null) { object value = null; if (o is Hashtable) { ReadHashTable(r, (Hashtable)o); } else if (o is Array) { value = ReadArray(name, (Array)o, r); } else if (o is IXmlSerializable) { IXmlSerializable xs = (IXmlSerializable)o; xs.ReadXml(r); } else { string s = r.ReadString(); value = ConvertToType(s, o.GetType()); } if (value != null) { this[name] = value; } } OnChanged(name); } } } } catch (Exception) { // Hey, at least we tried! } finally { using (r) {} } this.FileName = filename; }
/// <summary> /// Loads the specified settings file and deserializes values. It uses the existing /// settings to figure out the type to convert the strings to. /// </summary> /// <param name="filename">XmlNotepad settings xml file.</param> public void Load(string filename) { pfn = new PersistentFileNames(Settings.Instance.StartupPath); // we don't use the serializer because it's too slow to fire up. try { using (var r = new XmlTextReader(filename)) { if (r.IsStartElement("Settings")) { while (r.Read()) { if (r.NodeType == XmlNodeType.Element) { string name = r.Name; object o = map[name]; if (o != null) { object value = null; if (o is Hashtable) { ReadHashTable(r, (Hashtable)o); } else if (o is Array) { value = ReadArray(name, (Array)o, r); } else if (o is IXmlSerializable) { IXmlSerializable xs = (IXmlSerializable)o; xs.ReadXml(r); } else { string s = r.ReadString(); value = ConvertToType(s, o.GetType()); } if (value != null) { this[name] = value; } } OnChanged(name); } } } } } catch (Exception ex) { // Hey, at least we tried! Debug.WriteLine("Load settings failed: " + ex.Message); } this.FileName = filename; }
private void ReadConfig(string key, Type type, string configXml) { XmlReaderSettings settings = new XmlReaderSettings() { ConformanceLevel = ConformanceLevel.Fragment, IgnoreProcessingInstructions = false, }; using (StringReader sr = new StringReader(configXml)) using (XmlReader reader = XmlReader.Create(sr, settings)) { reader.MoveToContent(); if (typeof(IXmlSerializable).IsAssignableFrom(type) == true) { IXmlSerializable serializer = null; if (this.ContainsKey(key) == true) { serializer = this[key] as IXmlSerializable; serializer.ReadXml(reader); } else { serializer = Activator.CreateInstance(type) as IXmlSerializable; serializer.ReadXml(reader); this.Add(key, serializer); } } else { if (this.ContainsKey(key) == true) { var serializer = XmlSerializer.FromTypes(new Type[] { type, })[0]; this[key] = serializer.Deserialize(reader); } else { var serializer = XmlSerializer.FromTypes(new Type[] { type, })[0]; this.Add(key, serializer.Deserialize(reader)); } } } }
public static void Deserialize(string xml, IXmlSerializable serializable, XmlReaderSettings settings) { TextReader textReader = new StringReader(xml); using (XmlReader reader = XmlReader.Create(textReader, settings, CreateParserContext())) { reader.MoveToContent(); serializable.ReadXml(reader); } }
private object ReadSpecialContent(object obj) { IXmlSerializable xmlSerializable = (IXmlSerializable)obj; if (xmlSerializable != null) { xmlSerializable.ReadXml(this.m_reader); } return(obj); }
public override object Deserialize(XElement node, Type type, RoyalXmlSerializer serializer) { IXmlSerializable toReturn = (IXmlSerializable)Activator.CreateInstance(type); using (XmlReader reader = node.CreateReader()) { toReturn.ReadXml(reader); return(toReturn); } }
protected void DeserializeSelf(IXmlSerializable xmlSer, XmlElement element) { // the object can deserialize itself StringReader sr = new StringReader(element.InnerXml); XmlReader rd = XmlReader.Create(sr); xmlSer.ReadXml(rd); rd.Close(); sr.Close(); }
public static void Deserialize(IXmlSerializable readingObject, string serializedObject) { TextReader textReader = new StringReader(serializedObject); var settings = new XmlReaderSettings(); settings.IgnoreWhitespace = true; using (var xmlReader = XmlReader.Create(textReader, settings)) { readingObject.ReadXml(xmlReader); } }
// Token: 0x06007BB0 RID: 31664 RVA: 0x0022BD9C File Offset: 0x00229F9C public object Deserialize(XmlReader reader) { Invariant.Assert(reader != null); IXmlSerializable xmlSerializable = (IXmlSerializable)this._ctor.Invoke(new object[0]); if (reader.ReadState == ReadState.Initial) { reader.Read(); } xmlSerializable.ReadXml(reader); return(xmlSerializable); }
public override object ConvertXmlToObject(string s) { SqlString str2 = new SqlString(); StringReader input = new StringReader("<col>" + s + "</col>"); IXmlSerializable serializable = str2; using (XmlTextReader reader = new XmlTextReader(input)) { serializable.ReadXml(reader); } return(new SqlChars((SqlString)serializable)); }
public override object ConvertXmlToObject(string s) { SqlDateTime time = new SqlDateTime(); StringReader input = new StringReader("<col>" + s + "</col>"); IXmlSerializable serializable = time; using (XmlTextReader reader = new XmlTextReader(input)) { serializable.ReadXml(reader); } return((SqlDateTime)serializable); }
public override object ConvertXmlToObject(string s) { SqlGuid guid = new SqlGuid(); StringReader input = new StringReader("<col>" + s + "</col>"); IXmlSerializable serializable = guid; using (XmlTextReader reader = new XmlTextReader(input)) { serializable.ReadXml(reader); } return((SqlGuid)serializable); }
public override object ConvertXmlToObject(string s) { SqlBoolean flag = new SqlBoolean(); StringReader input = new StringReader("<col>" + s + "</col>"); IXmlSerializable serializable = flag; using (XmlTextReader reader = new XmlTextReader(input)) { serializable.ReadXml(reader); } return((SqlBoolean)serializable); }
protected IXmlSerializable ReadSerializable(IXmlSerializable serializable, bool wrappedAny) { string localName = null; string namespaceURI = null; if (wrappedAny) { localName = this.r.LocalName; namespaceURI = this.r.NamespaceURI; this.r.Read(); this.r.MoveToContent(); } serializable.ReadXml(this.r); if (wrappedAny) { while (this.r.NodeType == XmlNodeType.Whitespace) { this.r.Skip(); } if (this.r.NodeType == XmlNodeType.None) { this.r.Skip(); } if (((this.r.NodeType == XmlNodeType.EndElement) && (this.r.LocalName == localName)) && (this.r.NamespaceURI == namespaceURI)) { this.Reader.Read(); } } return serializable; }
/// <include file='doc\XmlSerializationReader.uex' path='docs/doc[@for="XmlSerializationReader.ReadSerializable"]/*' /> protected IXmlSerializable ReadSerializable(IXmlSerializable serializable, bool wrappedAny) { string name = null; string ns = null; if (wrappedAny) { name = r.LocalName; ns = r.NamespaceURI; r.Read(); r.MoveToContent(); } serializable.ReadXml(r); if (wrappedAny) { while (r.NodeType == XmlNodeType.Whitespace) r.Skip(); if (r.NodeType == XmlNodeType.None) r.Skip(); if (r.NodeType == XmlNodeType.EndElement && r.LocalName == name && r.NamespaceURI == ns) { Reader.Read(); } } return serializable; }
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; }
protected IXmlSerializable ReadSerializable (IXmlSerializable serializable) { if (ReadNull ()) return null; int depth = reader.Depth; readCount++; serializable.ReadXml (reader); Reader.MoveToContent (); while (reader.Depth > depth) reader.Skip (); if (reader.Depth == depth && reader.NodeType == XmlNodeType.EndElement) reader.ReadEndElement (); return serializable; }
/// <include file='doc\XmlSerializationReader.uex' path='docs/doc[@for="XmlSerializationReader.ReadSerializable"]/*' /> protected IXmlSerializable ReadSerializable(IXmlSerializable serializable) { serializable.ReadXml(r); return serializable; }