internal static bool DecodeXmlTextReaderValue(object instance, PropertyInfo propertyInfo, XmlReader xmlTextReader) { try { // find related property by name if not provided as parameter if (propertyInfo == null) propertyInfo = instance.GetType().GetProperty(xmlTextReader.Name, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance); if (propertyInfo == null) return false; // unescaped characters <>& if (propertyInfo.PropertyType.Equals(typeof(string))) propertyInfo.SetValue(instance, Decode(xmlTextReader.ReadInnerXml().Trim()), null); else if (propertyInfo.PropertyType.Equals(typeof(DateTime))) propertyInfo.SetValue(instance, ParseRfc822DateTime(xmlTextReader.ReadInnerXml().Trim()), null); else propertyInfo.SetValue(instance, TypeDescriptor.GetConverter(propertyInfo.PropertyType).ConvertFromString(xmlTextReader.ReadInnerXml().Trim()), null); } catch (Exception e) { Debug.WriteLine(propertyInfo.Name + ", " + propertyInfo.PropertyType.Name + " / " + instance.ToString() + " " + e.Message); return false; } return true; }
public override void PopulateFromXml(XmlReader reader) { if (reader.LocalName != "item" || reader.GetAttribute("type") != "category") return; // If we weren't on the right kind of node, do nothing GuidStr = reader.GetAttribute("guid"); while (reader.Read()) { switch (reader.NodeType) { case XmlNodeType.Element: { switch (reader.LocalName) { case "item": if (reader.GetAttribute("type") == "category") { var child = new CanonicalPartOfSpeechItem(); child.PopulateFromXml(reader); AppendChild(child); } break; case "abbrev": AddAbbrev(reader.GetAttribute("ws"), reader.ReadInnerXml()); break; case "term": AddName(reader.GetAttribute("ws"), reader.ReadInnerXml()); break; case "def": AddDescription(reader.GetAttribute("ws"), reader.ReadInnerXml()); break; case "citation": Dictionary<string, List<string>> citationsDict = GetExtraDataWsDict<string>("citations"); string ws = reader.GetAttribute("ws"); List<string> citations = GetListFromDict<string>(citationsDict, ws); citations.Add(reader.ReadInnerXml()); // No need to set anything in ExtraData, as GetListFromDict did it for us. break; } break; } case XmlNodeType.EndElement: { if (reader.LocalName == "item") { Key = AbbrevByWs(KeyWs); reader.Read(); // Skip past the closing element before returning return; } break; } } } }
internal Effects(System.Xml.XmlReader reader) { Volume = reader.GetIntegerAttribute("Volume"); FadeInTime = reader.GetIntegerAttributeOrDefault("FadeIn", 0); FadeOutTime = reader.GetIntegerAttributeOrDefault("FadeOut", 0); CrossFading = reader.GetBooleanAttributeOrDefault("CrossFading", false); HasRandomVolume = reader.GetBooleanAttributeOrDefault("HasRandomVolume", false); MinRandomVolume = reader.GetIntegerAttributeOrDefault("MinRandomVolume", 50); MaxRandomVolume = reader.GetIntegerAttributeOrDefault("MaxRandomVolume", 100); m_Pitch = new IntEffect("Pitch", reader, 0); m_Balance = new BalanceEffect(reader); m_Volume = new IntEffect("Volume", reader, 0); m_Speakers = new SpeakerAssignmentEffect(reader); m_Reverb = new ReverbEffect(reader); m_Tempo = new IntEffect("Tempo", reader, 0); #region tdmod m_CueIn = new CueEffect("CueIn", reader); m_CueOut = new CueEffect("CueOut", reader); #endregion if (reader.IsEmptyElement) { reader.Read(); } else { reader.Read(); reader.ReadInnerXml(); reader.ReadEndElement(); } }
public void ReadXml(XmlReader reader) { //goto inner hidden reader.Read(); Text = reader.ReadInnerXml(); reader.Read(); }
public void ReadXml(XmlReader reader) { m_name = reader.Name; while (reader.Read()) { reader.SkipEmptyNodes(); if (reader.NodeType == XmlNodeType.EndElement) { // the end break; } else if (reader.NodeType == XmlNodeType.Element) { reader.Read(); // go into ValueNode reader.SkipEmptyNodes(); } if (reader.NodeType != XmlNodeType.Text) { throw new Exception("Required NodeType: Text - Found: " + reader.NodeType); } var value = reader.ReadContentAsString(); Pairs.Add(new KeyValuePair<string, string>(reader.Name, value)); if (reader.NodeType == XmlNodeType.EndElement) { // the end reader.ReadInnerXml(); } } }
/// <summary> /// Creates an instance of the ReadWriteAttributeAssignment using the provided XmlReader. /// </summary> /// <param name="reader">The XmlReader positioned at the AttributeAssignament node.</param> /// <param name="schemaVersion">The version of the schema that was used to validate.</param> public AttributeAssignmentElementReadWrite(XmlReader reader, XacmlVersion schemaVersion) : base(XacmlSchema.Policy, schemaVersion) { if (reader == null) throw new ArgumentNullException("reader"); if (reader.LocalName == Consts.Schema1.ObligationElement.AttributeAssignment && ValidateSchema(reader, schemaVersion)) { if (reader.HasAttributes) { // Load all the attributes while (reader.MoveToNextAttribute()) { if (reader.LocalName == Consts.Schema1.AttributeValueElement.DataType) { _dataType = reader.GetAttribute(Consts.Schema1.AttributeValueElement.DataType); } else if (reader.LocalName == Consts.Schema1.AttributeAssignmentElement.AttributeId) { _attributeId = reader.GetAttribute(Consts.Schema1.AttributeAssignmentElement.AttributeId); } } reader.MoveToElement(); } // Load the node contents _contents = reader.ReadInnerXml(); } else { throw new Exception(string.Format(Properties.Resource.exc_invalid_node_name, reader.LocalName)); } }
public static object Deserialize(Type type, XmlReader reader, bool readInnerXml) { if (null == type) throw new ArgumentNullException("type"); if (null == reader) throw new ArgumentNullException("reader"); if (reader.NodeType != XmlNodeType.Element) throw new ArgumentException("reader is not positioned on an element"); object value = null; StringBuilder serializationBuilder = new StringBuilder(); serializationBuilder.Append("<?xml version=\"1.0\"?>"); if (readInnerXml) { serializationBuilder.AppendLine(reader.ReadInnerXml()); } else { serializationBuilder.AppendLine(reader.ReadOuterXml()); } string serialization = serializationBuilder.ToString(); using (StringReader stringReader = new StringReader(serialization)) { XmlSerializer serializer = new XmlSerializer(type); value = serializer.Deserialize(stringReader); } return value; }
/// <summary> /// Implements a custom deserialization of the key, using the type name as a type specifier. /// </summary> /// <param name="reader"></param> /// <returns></returns> protected override Type DeserializeKey(System.Xml.XmlReader reader) { var keyXml = reader.ReadInnerXml(); var key = Type.GetType(keyXml); return(key); }
public void ReadXml(System.Xml.XmlReader reader) { bool wasEmpty = reader.IsEmptyElement; reader.Read(); if (wasEmpty) { return; } while (reader.NodeType != System.Xml.XmlNodeType.EndElement) { CustomProperty cp = new CustomProperty(); cp.name = reader.GetAttribute("Name"); cp.description = reader.GetAttribute("Description"); string type = reader.GetAttribute("Type"); if (type == "string") { cp.type = typeof(string); } if (type == "bool") { cp.type = typeof(bool); } if (type == "Vector2") { cp.type = typeof(Vector2); } if (type == "Color") { cp.type = typeof(Color); } if (type == "Item") { cp.type = typeof(Component); } if (cp.type == typeof(Component)) { cp.value = reader.ReadInnerXml(); this.Add(cp.name, cp); } else { reader.ReadStartElement("Property"); XmlSerializer valueSerializer = new XmlSerializer(cp.type); object obj = valueSerializer.Deserialize(reader); cp.value = Convert.ChangeType(obj, cp.type); this.Add(cp.name, cp); reader.ReadEndElement(); } reader.MoveToContent(); } reader.ReadEndElement(); }
public override void ReadXml(XmlReader reader) { Name = reader.GetAttribute("name"); Description = reader.ReadInnerXml().Trim(); if (Description.Contains("this method interface declaration")) { } }
public string FromXmlReader (XmlReader reader) { if (!reader.ReadToDescendant ("head")) return null; if (!reader.ReadToNextSibling ("body")) return null; return reader.ReadInnerXml (); }
public static string InnerXml(this XElement node) { Debug.Assert(node != null); System.Xml.XmlReader reader = node.CreateReader(); _ = reader.MoveToContent(); return(reader.ReadInnerXml()); }
/// <summary> /// 读取Xml /// </summary> /// <param name="reader"></param> public void ReadXml(XmlReader reader) { String prefix = reader.Prefix; String xml = reader.ReadInnerXml(); if (xml.StartsWith("<Fault") || xml.StartsWith("<" + prefix + ":Fault")) Fault = xml; else Xml = xml; }
private static SecurityKeyIdentifierClause ReadRSAKeyValue(XmlReader reader) { string rsaXmlElement = reader.ReadInnerXml(); var rsa = new RSACryptoServiceProvider(); // Do not dispose! Used later when creating key rsa.FromXmlString(rsaXmlElement); RsaKeyIdentifierClause clause = new RsaKeyIdentifierClause(rsa); return clause; }
public void ReadXml(System.Xml.XmlReader reader) { XmlSerializer stringSerializer = new XmlSerializer(typeof(string)); XmlSerializer intSerializer = new XmlSerializer(typeof(int)); bool wasEmpty = reader.IsEmptyElement; reader.Read(); if (wasEmpty) { return; } reader.MoveToContent(); while (reader.NodeType != System.Xml.XmlNodeType.EndElement) { string element = reader.Name.ToLower(); reader.ReadStartElement(); switch (element) { case "name": Name = (string)stringSerializer.Deserialize(reader); break; case "league": League = (Leagues)intSerializer.Deserialize(reader); break; case "race": Race = (Matchup.Races)intSerializer.Deserialize(reader); break; case "points": Points = (int)intSerializer.Deserialize(reader); break; case "place": Place = (int)intSerializer.Deserialize(reader); break; default: reader.ReadInnerXml(); break; } reader.ReadEndElement(); reader.MoveToContent(); } reader.ReadEndElement(); }
public void ReadXml(System.Xml.XmlReader reader) { if (!reader.IsEmptyElement) { string ruleSetXml = reader.ReadInnerXml(); XmlReader innerReader = XmlReader.Create(new StringReader(ruleSetXml)); WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer(); RuleSet = serializer.Deserialize(innerReader) as RuleSet; } }
void System.Xml.Serialization.IXmlSerializable.ReadXml(Xml.XmlReader reader) { var content = reader.ReadInnerXml(); string mediatype; byte[] bytes; ParseInternal(content, out mediatype, out bytes); this._MediaType = mediatype; this._Bytes = bytes; }
void IXmlSerializable.ReadXml(XmlReader reader) { string s = reader.ReadInnerXml(); string startTag = "<![CDATA["; string endTag = "]]>"; char[] trims = new char[] { '\r', '\n', '\t', ' ' }; s = s.Trim(trims); if (s.StartsWith(startTag) && s.EndsWith(endTag)) { s = s.Substring(startTag.Length, s.LastIndexOf(endTag) - startTag.Length); } this._innerSourceXml = s; this._innerXml = s.Trim(trims); }
private string ReadXmlFile() { using (Xml.XmlReader reader = Xml.XmlReader.Create("TestXml.xml")) { var text = reader.ReadInnerXml(); while (reader.Read()) { int a = 100; } } return(String.Empty); }
/// <summary> /// Creates an instance of the AttributeValue using the XmlReader provided. /// </summary> /// <param name="reader">The XmlReader positioned at the AttributeValue node.</param> /// <param name="schemaVersion">The version of the schema that was used to validate.</param> public AttributeValueElementReadWrite(XmlReader reader, XacmlVersion schemaVersion) : base(XacmlSchema.Context, schemaVersion) { if (reader == null) throw new ArgumentNullException("reader"); if (reader.LocalName == Consts.ContextSchema.AttributeElement.AttributeValue && ValidateSchema(reader, schemaVersion)) { // Load the node contents _contents = reader.ReadInnerXml(); } else { throw new Exception(string.Format(Properties.Resource.exc_invalid_node_name, reader.LocalName)); } }
public void ReadXml(System.Xml.XmlReader reader) { if (reader.IsEmptyElement) { reader.ReadStartElement(); return; } string someDate = reader.ReadInnerXml(); if (StringExtensions.IsNullOrWhiteSpace(someDate) == false) { Value = XmlConvert.ToDateTime(someDate, XML_DATE_FORMAT); } }
public new void ReadXml(System.Xml.XmlReader reader) { while (reader.Read()) { base.ReadXml(reader); if (reader.NodeType == System.Xml.XmlNodeType.Element) { switch (reader.Name) { case "GenericData": string innerXML = reader.ReadInnerXml(); GenericData = innerXML; break; } } } }
/// <summary> /// Initializes a new instance of the <see cref="XmlSerializationContextInfo" /> class. /// </summary> /// <param name="xmlReader">The XML reader.</param> /// <param name="model">The model.</param> /// <exception cref="ArgumentNullException">The <paramref name="xmlReader" /> is <c>null</c>.</exception> /// <exception cref="ArgumentNullException">The <paramref name="model" /> is <c>null</c>.</exception> public XmlSerializationContextInfo(XmlReader xmlReader, ModelBase model) { Argument.IsNotNull("xmlReader", xmlReader); Argument.IsNotNull("model", model); var modelType = model.GetType(); var elementStart = string.Format("<{0}", modelType.Name); if (xmlReader.HasAttributes) { for (int i = 0; i < xmlReader.AttributeCount; i++) { xmlReader.MoveToAttribute(i); var attributeName = xmlReader.LocalName; var attributeValue = xmlReader.Value; elementStart += string.Format(" {0}=\"{1}\"", attributeName, attributeValue); } xmlReader.MoveToElement(); } elementStart += ">"; xmlReader.MoveToContent(); var xmlContent = xmlReader.ReadInnerXml(); if (xmlContent.StartsWith("<")) { #if SL5 xmlContent = System.Windows.Browser.HttpUtility.HtmlDecode(xmlContent); #else xmlContent = System.Net.WebUtility.HtmlDecode(xmlContent); #endif } var elementEnd = string.Format("</{0}>", modelType.Name); var finalXmlContent = string.Format("{0}{1}{2}", elementStart, xmlContent, elementEnd); Initialize(finalXmlContent, model); }
/// <summary> /// Generates a <see cref="SerializableError"/> object from its XML representation. /// </summary> /// <param name="reader">The <see cref="XmlReader"/> stream from which the object is deserialized.</param> public void ReadXml(XmlReader reader) { if (reader.IsEmptyElement) { reader.Read(); return; } reader.ReadStartElement(); while (reader.NodeType != XmlNodeType.EndElement) { var key = XmlConvert.DecodeName(reader.LocalName); var value = reader.ReadInnerXml(); SerializableError.Add(key, value); reader.MoveToContent(); } reader.ReadEndElement(); }
/// <summary>Initializes a new instance of RssCloud</summary> public RssCloud(XmlReader xmlTextReader) { if (!xmlTextReader.HasAttributes) return; PropertyInfo propertyInfo = null; while (xmlTextReader.MoveToNextAttribute()) { // find related property by name propertyInfo = GetType().GetProperty(xmlTextReader.Name, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance); if (propertyInfo != null) { // Protocol enum needs some conversion before the typeconverter can set the values that contains - char if (propertyInfo.Name == "Protocol") propertyInfo.SetValue(this, TypeDescriptor.GetConverter(propertyInfo.PropertyType).ConvertFromString(xmlTextReader.ReadInnerXml().Trim().Replace("-", "")), null); else XmlSerializationUtil.DecodeXmlTextReaderValue(this, xmlTextReader); } } }
public void ReadXml(XmlReader reader) { try { string inner = reader.ReadInnerXml(); string text = string.Empty; var matches = reg.Matches( inner ); if( matches.Count > 0 ) { text = string.Join( "\n", matches.Cast<Match>().Select( x => x.Groups[1].Value ) ); } Text = HttpUtility.HtmlDecode( text ); } catch (Exception) { } }
public IEnumerable<IDataObject> BindRdfDataObjects(XmlReader xmlReader) { SkipToStartElement(xmlReader); while(!xmlReader.EOF) { if (xmlReader.NodeType != XmlNodeType.Element) SkipToStartElement(xmlReader); if (!xmlReader.EOF) { var resource = xmlReader.GetAttribute("about", RdfNamespace); if (resource != null) { var dataobject = BindRdfDataObject(resource, xmlReader.NamespaceURI + xmlReader.LocalName, xmlReader); if (dataobject != null) yield return dataobject; } else { xmlReader.ReadInnerXml(); } } } }
/// <summary> /// Initializes a new instance of the <see cref="XmlSerializationContextInfo" /> class. /// </summary> /// <param name="xmlReader">The XML reader.</param> /// <param name="model">The model.</param> /// <exception cref="ArgumentNullException">The <paramref name="xmlReader" /> is <c>null</c>.</exception> /// <exception cref="ArgumentNullException">The <paramref name="model" /> is <c>null</c>.</exception> public XmlSerializationContextInfo(XmlReader xmlReader, ModelBase model) { Argument.IsNotNull("xmlReader", xmlReader); Argument.IsNotNull("model", model); xmlReader.MoveToContent(); var xmlContent = xmlReader.ReadInnerXml(); if (xmlContent.StartsWith("<")) { #if SL5 xmlContent = System.Windows.Browser.HttpUtility.HtmlDecode(xmlContent); #else xmlContent = System.Net.WebUtility.HtmlDecode(xmlContent); #endif } var modelType = model.GetType(); var elementStart = string.Format("<{0}>", modelType.Name); var elementEnd = string.Format("</{0}>", modelType.Name); var finalXmlContent = string.Format("{0}{1}{2}", elementStart, xmlContent, elementEnd); Initialize(finalXmlContent, model); }
public void Read(XmlReader reader, object instance) { ((Custom) instance).InnerXml = reader.ReadInnerXml(); }
public void ReadXml(XmlReader reader) { if (reader.IsEmptyElement) return; ReadXml(reader.ReadInnerXml()); }
public void ReadInnerXml (XmlReader reader) { reader.Read (); reader.Read (); Assert.AreEqual (ReadState.Interactive, reader.ReadState, "initial.ReadState"); Assert.AreEqual (false, reader.EOF, "initial.EOF"); Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "initial.NodeType"); string s = reader.ReadInnerXml (); Assert.AreEqual ("test of <b>mixed</b> string.", s, "read_all"); Assert.AreEqual ("bar", reader.Name, "after.Name"); Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "after.NodeType"); }
private void ReadInnerXmlOnEndElement (XmlReader xmlReader) { xmlReader.Read (); xmlReader.Read (); xmlReader.Read (); Assert.AreEqual (String.Empty, xmlReader.ReadInnerXml ()); }
/// <summary>Initializes a new instance of RssCloud</summary> public RssCloud(System.Xml.XmlReader xmlTextReader) { if (!xmlTextReader.HasAttributes) { return; } // System.Reflection.PropertyInfo propertyInfo = null; // while (xmlTextReader.MoveToNextAttribute()) { // find related property by name propertyInfo = GetType().GetProperty(xmlTextReader.Name, System.Reflection.BindingFlags.IgnoreCase | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance); if (propertyInfo != null) { // Protocol enum needs some conversion before the typeconverter can set the values that contains - char if (propertyInfo.Name == "Protocol") { propertyInfo.SetValue(this, System.ComponentModel.TypeDescriptor.GetConverter(propertyInfo.PropertyType).ConvertFromString(xmlTextReader.ReadInnerXml().Trim().Replace("-", "")), null); } else { XmlSerializationUtil.DecodeXmlTextReaderValue(this, xmlTextReader); } } } }
public override string ReadInnerXml() { return(reader.ReadInnerXml()); }
/// <summary>Initializes a new instance of OpmlOutline</summary> public OpmlOutline(System.Xml.XmlReader xmlTextReader) : this() { if (!xmlTextReader.HasAttributes) { return; } // get attributes System.Reflection.PropertyInfo propertyInfo = null; for (int i = 0; i < xmlTextReader.AttributeCount; i++) { xmlTextReader.MoveToAttribute(i); // try to find some common used alias names for attributes string attributeName = xmlTextReader.Name; if (attributeName.IndexOf("url") != -1) { attributeName = "xmlUrl"; } if (attributeName.IndexOf("title") != -1) { attributeName = "text"; } // find related property by name propertyInfo = GetType().GetProperty(attributeName, System.Reflection.BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance); if (propertyInfo != null) { propertyInfo.SetValue(this, System.ComponentModel.TypeDescriptor.GetConverter(propertyInfo.PropertyType).ConvertFromString(xmlTextReader.ReadInnerXml().Trim()), null); } } }
private VkDocType GetVkDocType(XmlReader xml) { var type = new VkDocType {FullName = GetMemberName(xml, "T:")}; while (xml.Read()) { if (xml.NodeType == XmlNodeType.EndElement && xml.Name == "member") break; if (xml.NodeType == XmlNodeType.Element && xml.Name == "summary") { //type.Summary = xml.ReadElementContentAsString().Trim(); type.Summary = xml.ReadInnerXml().Trim(); } } return type; }
protected override bool OnDeserializeUnrecognizedElement(string elementName, System.Xml.XmlReader reader) { if (OptionElements == null) { OptionElements = new NameValueCollection(); } //Because ConfigurationElement.DeserializeElemenet() method only accept outerXml and in MS.NET, it accept innerXml, //so there is a hack over here OptionElements.Add(elementName, Platform.IsMono ? reader.ReadOuterXml() : reader.ReadInnerXml()); return(true); }
public override string ReadInnerXml() { CheckAsync(); return(coreReader.ReadInnerXml()); }
private Win32API.KeyEvent JudgeKeyevent(XmlReader reader, Win32API.KeyEvent keyEvent) { while (reader.Read()) { if (reader.NodeType == XmlNodeType.Element && reader.Name == "KeyEvent") { string eventName = reader.ReadInnerXml(); if (eventName == KeyboardEvents.WM_KeyUp.ToString()) { keyEvent.dwFlags = Win32API.KBEventFlag.KeyUp; } else if (eventName == KeyboardEvents.WM_KeyDown.ToString()) { keyEvent.dwFlags = Win32API.KBEventFlag.KeyDown; } break; } } return keyEvent; }
public void ConsumeNodeXml(XmlReader xml, string domainNodeId, string documentLibraryUrl) { if (xml != null && xml.NodeType == XmlNodeType.Element && xml.Name == "node") { #region Attribute Values #region Id if (xml.MoveToAttribute("id")) { Id = xml.Value; } #endregion #region NodeType if (Id == domainNodeId) { _nodeType = IoCContainer.GetInjectionInstance().GetInstance<DomainNode>(); } else { if (xml.MoveToAttribute("type")) { switch (xml.Value) { case CON_NODE_TYPE_ID: _nodeType = IoCContainer.GetInjectionInstance().GetInstance<ConNode>(); break; case DECISION_NODE_TYPE_ID: _nodeType = IoCContainer.GetInjectionInstance().GetInstance<DecisionNode>(); break; case IDEA_NODE_TYPE_ID: _nodeType = IoCContainer.GetInjectionInstance().GetInstance<IdeaNode>(); break; case MAP_NODE_TYPE_ID: _nodeType = IoCContainer.GetInjectionInstance().GetInstance<MapNode>(); break; case PRO_NODE_TYPE_ID: _nodeType = IoCContainer.GetInjectionInstance().GetInstance<ProNode>(); break; case QUESTION_NODE_TYPE_ID: _nodeType = IoCContainer.GetInjectionInstance().GetInstance<QuestionNode>(); break; case REFERENCE_NODE_TYPE_ID: _nodeType = IoCContainer.GetInjectionInstance().GetInstance<ReferenceNode>(); break; case ARGUMENT_NODE_TYPE_ID: _nodeType = IoCContainer.GetInjectionInstance().GetInstance<ArgumentNode>(); break; case NOTE_NODE_TYPE_ID: _nodeType = IoCContainer.GetInjectionInstance().GetInstance<NoteNode>(); break; case LIST_NODE_TYPE_ID: _nodeType = IoCContainer.GetInjectionInstance().GetInstance<ListNode>(); break; default: break; } } } #endregion #region CreatedBy if (xml.MoveToAttribute("author")) { CreatedBy = xml.Value; } #endregion #region Created if (xml.MoveToAttribute("created")) { string createdMillisecondsXmlValue = xml.Value; long createdMilliseconds; if (long.TryParse(createdMillisecondsXmlValue, out createdMilliseconds)) { Created = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc); Created = Created.AddMilliseconds(createdMilliseconds); } } #endregion #region LastModified if (xml.MoveToAttribute("lastModified")) { string lastModifiedMillisecondsXmlValue = xml.Value; long lastModifiedMilliseconds; if (long.TryParse(lastModifiedMillisecondsXmlValue, out lastModifiedMilliseconds)) { LastModified = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc); LastModified = LastModified.AddMilliseconds(lastModifiedMilliseconds); } } #endregion #region Name if (xml.MoveToAttribute("label")) { Name = xml.Value; } #endregion #region LastModifiedBy if (xml.MoveToAttribute("lastModificationAuthor")) { LastModifiedBy = xml.Value; } #endregion #endregion while (xml.Read()) { if (xml.NodeType == XmlNodeType.Element) { if (_nodeType.Name == "CompendiumReferenceNode") { if (xml.Name.ToLower() == "source") { string fullFilePath = xml.ReadInnerXml(); if (!string.IsNullOrEmpty(fullFilePath)) { if (fullFilePath.ToLower().StartsWith("http://") || fullFilePath.ToLower().StartsWith("https://") || fullFilePath.ToLower().StartsWith("ftp://") || fullFilePath.ToLower().StartsWith("ftps://")) { Attachment = fullFilePath; } else { string linkedFileName = string.Empty; if (fullFilePath.LastIndexOf("/") < 0 && fullFilePath.LastIndexOf("\\") > 0) { linkedFileName = fullFilePath.Substring(fullFilePath.LastIndexOf("\\") + 1); } else { linkedFileName = fullFilePath.Substring(fullFilePath.LastIndexOf("/") + 1); } Attachment = documentLibraryUrl + linkedFileName; //set the file name, the node name is can change independently } } } } } else if (xml.NodeType == XmlNodeType.EndElement && xml.Name == "node") { break; } } } }
private void ParseCallback(XmlReader reader) { if (reader.NodeType == XmlNodeType.Element) { string localName = reader.LocalName; if (XmlNames.ElementEquals(localName, XmlNames.ExampleElementName) && _comment.ExampleText == null) { _comment.ExampleText = reader.ReadInnerXml().Trim(); // TODO: trim each line } else if (XmlNames.ElementEquals(localName, XmlNames.SummaryElementName) && _comment.SummaryText == null) { _comment.SummaryText = reader.ReadInnerXml().Trim(); // TODO: trim each line } else if (XmlNames.ElementEquals(localName, XmlNames.ReturnsElementName) && _comment.ReturnsText == null) { _comment.ReturnsText = reader.ReadInnerXml().Trim(); // TODO: trim each line } else if (XmlNames.ElementEquals(localName, XmlNames.RemarksElementName) && _comment.RemarksText == null) { _comment.RemarksText = reader.ReadInnerXml().Trim(); // TODO: trim each line } else if (XmlNames.ElementEquals(localName, XmlNames.ParameterElementName)) { string name = reader.GetAttribute(XmlNames.NameAttributeName); string paramText = reader.ReadInnerXml(); if (!string.IsNullOrWhiteSpace(name) && !_comment._parameterTexts.ContainsKey(name)) { (_parameterNamesBuilder ?? (_parameterNamesBuilder = ImmutableArray.CreateBuilder<string>())).Add(name); _comment._parameterTexts.Add(name, paramText.Trim()); // TODO: trim each line } } else if (XmlNames.ElementEquals(localName, XmlNames.TypeParameterElementName)) { string name = reader.GetAttribute(XmlNames.NameAttributeName); string typeParamText = reader.ReadInnerXml(); if (!string.IsNullOrWhiteSpace(name) && !_comment._typeParameterTexts.ContainsKey(name)) { (_typeParameterNamesBuilder ?? (_typeParameterNamesBuilder = ImmutableArray.CreateBuilder<string>())).Add(name); _comment._typeParameterTexts.Add(name, typeParamText.Trim()); // TODO: trim each line } } else if (XmlNames.ElementEquals(localName, XmlNames.ExceptionElementName)) { string type = reader.GetAttribute(XmlNames.CrefAttributeName); string exceptionText = reader.ReadInnerXml(); if (!string.IsNullOrWhiteSpace(type)) { if (_exceptionTextBuilders == null || !_exceptionTextBuilders.ContainsKey(type)) { (_exceptionTypesBuilder ?? (_exceptionTypesBuilder = ImmutableArray.CreateBuilder<string>())).Add(type); (_exceptionTextBuilders ?? (_exceptionTextBuilders = new Dictionary<string, ImmutableArray<string>.Builder>())).Add(type, ImmutableArray.CreateBuilder<string>()); } _exceptionTextBuilders[type].Add(exceptionText); } } else if (XmlNames.ElementEquals(localName, XmlNames.CompletionListElementName)) { string cref = reader.GetAttribute(XmlNames.CrefAttributeName); if (!string.IsNullOrWhiteSpace(cref)) { _comment.CompletionListCref = cref; } reader.ReadInnerXml(); } else { // This is an element we don't handle. Skip it. reader.Read(); } } else { // We came across something that isn't a start element, like a block of text. // Skip it. reader.Read(); } }
void ReadXml(XmlReader reader) { CommonUtility.AssertNotNull("reader", reader); this.AdditionalDetails = new Dictionary<string, string>(); reader.ReadStartElement(); while (reader.IsStartElement()) { if (reader.IsEmptyElement) { reader.Skip(); } else { if ((string.Compare(reader.LocalName, Constants.ErrorCode, StringComparison.OrdinalIgnoreCase) == 0) || (string.Compare(reader.LocalName, Constants.ErrorCodePreview, StringComparison.Ordinal) == 0)) { this.ErrorCode = reader.ReadElementContentAsString(); } else if ((string.Compare(reader.LocalName, Constants.ErrorMessage, StringComparison.OrdinalIgnoreCase) == 0) || (string.Compare(reader.LocalName, Constants.ErrorMessagePreview, StringComparison.Ordinal) == 0)) { this.ErrorMessage = reader.ReadElementContentAsString(); } else if (string.Compare(reader.LocalName, Constants.ErrorException, StringComparison.OrdinalIgnoreCase) == 0) { reader.ReadStartElement(); while (reader.IsStartElement()) { switch (reader.LocalName) { case Constants.ErrorExceptionMessage: this.AdditionalDetails.Add( Constants.ErrorExceptionMessage, reader.ReadElementContentAsString(Constants.ErrorExceptionMessage, string.Empty)); break; case Constants.ErrorExceptionStackTrace: this.AdditionalDetails.Add( Constants.ErrorExceptionStackTrace, reader.ReadElementContentAsString(Constants.ErrorExceptionStackTrace, string.Empty)); break; default: reader.Skip(); break; } } reader.ReadEndElement(); } else { this.AdditionalDetails.Add( reader.LocalName, reader.ReadInnerXml()); } } } reader.ReadEndElement(); }
void IXmlSerializable.ReadXml(XmlReader reader) { string text = reader.ReadInnerXml(); this.RawValue = DeserializeStringSafe(text).RawValue; }
void DoDeserializeSection (XmlReader reader) { reader.MoveToContent (); string protection_provider = null; string config_source = null; string localName; while (reader.MoveToNextAttribute ()) { localName = reader.LocalName; if (localName == "configProtectionProvider") protection_provider = reader.Value; else if (localName == "configSource") config_source = reader.Value; } /* XXX this stuff shouldn't be here */ { if (protection_provider != null) { ProtectedConfigurationProvider prov = ProtectedConfiguration.GetProvider (protection_provider, true); XmlDocument doc = new ConfigurationXmlDocument (); reader.MoveToElement (); doc.Load (new StringReader (reader.ReadInnerXml ())); XmlNode n = prov.Decrypt (doc); reader = new XmlNodeReader (n); SectionInformation.ProtectSection (protection_provider); reader.MoveToContent (); } } if (config_source != null) SectionInformation.ConfigSource = config_source; SectionInformation.SetRawXml (RawXml); if (SectionHandler == null) DeserializeElement (reader, false); }
/// <summary> /// This method retrieves an XmlReader within a specified context. /// Moreover it collects label values before or after a geometry could be found. /// </summary> /// <param name="reader">An XmlReader instance that is the origin of a created sub-reader</param> /// <param name="labelValue">A string array for recording a found label value. Pass 'null' to ignore searching for label values</param> /// <param name="pathNodes">A list of <see cref="IPathNode"/> instances defining the context of the retrieved reader</param> /// <returns>A sub-reader of the XmlReader given as argument</returns> protected XmlReader GetSubReaderOf(XmlReader reader, string[] labelValue, List<IPathNode> pathNodes) { string errorMessage = null; while (reader.Read()) { if (reader.NodeType == XmlNodeType.Element) { if (pathNodes[0].Matches(reader)) { pathNodes.RemoveAt(0); if (pathNodes.Count > 0) return GetSubReaderOf(reader.ReadSubtree(), null, pathNodes); return reader.ReadSubtree(); } if (labelValue != null) if (_LabelNode != null) if (_LabelNode.Matches(reader)) labelValue[0] = reader.ReadElementString(); if (_ServiceExceptionNode.Matches(reader)) { errorMessage = reader.ReadInnerXml(); Trace.TraceError("A service exception occured: " + errorMessage); throw new Exception("A service exception occured: " + errorMessage); } } } return null; }
private static ITestCommand ReadTestCommand(System.Xml.XmlReader reader, string comment, string sessionId) { var cmd = ReadCommand(reader, comment, sessionId); if (cmd != null) { return(cmd); } switch (reader.LocalName) { case "AssertMatch": var result = new AssertMatch() { Comment = comment, Match = reader.GetAttribute("match") }; var removeSys = reader.GetAttribute("removeSysProps"); result.RemoveSystemProperties = (removeSys != "0"); using (var subReader = reader.ReadSubtree()) { subReader.Read(); while (!subReader.EOF) { if (reader.NodeType == XmlNodeType.Element) { switch (reader.LocalName) { case "Remove": result.Removes.Add(reader.GetAttribute("match")); subReader.Read(); break; case "Expected": bool isXml; result.Expected = ProcessXmlValue(reader.ReadInnerXml(), out isXml); result.IsXml = isXml; break; default: subReader.Read(); break; } } else { subReader.Read(); } } } reader.Read(); return(result); case "DownloadFile": return(new DownloadFile() { Comment = comment, Text = reader.ReadInnerXml() }); } return(null); }