public abstract WriteCData ( string text ) : void | ||
text | string | |
return | void |
public void SaveTo(System.Xml.XmlWriter x) { foreach (var t in LinkTargetConfigurations) { x.WriteStartElement("TargetConfiguration"); t.SaveTo(x); x.WriteEndElement(); } x.WriteStartElement("DefaultLibs"); foreach (var lib in DefaultLibraries) { x.WriteStartElement("lib"); x.WriteCData(lib); x.WriteEndElement(); } x.WriteEndElement(); x.WriteStartElement("Includes"); foreach (var inc in GlobalParseCache.DirectoryPaths) { x.WriteStartElement("Path"); x.WriteCData(inc); x.WriteEndElement(); } x.WriteEndElement(); }
/// <summary> /// Writes the error data that belongs in child nodes. /// </summary> /// <param name="xmlWriter">The XML writer.</param> protected void WriteInnerXml(System.Xml.XmlWriter w) { if (w == null) { throw new ArgumentNullException("w"); } // message + detail if ((!string.IsNullOrEmpty(Message)) || (!string.IsNullOrEmpty(Detail))) { w.WriteStartElement("message"); w.WriteAttributeStringIf("text", Message); if (!string.IsNullOrEmpty(Detail)) { w.WriteCData(Detail); } w.WriteEndElement(); } // htmlErrorMessage if (!string.IsNullOrEmpty(HtmlErrorMessage)) { w.WriteStartElement("htmlErrorMessage"); w.WriteCData(HtmlErrorMessage); w.WriteEndElement(); } // collections w.WriteCollectionIf("serverVariables", new HttpValuesCollection(ServerVariable)); w.WriteCollectionIf("queryString", new HttpValuesCollection(QueryString)); w.WriteCollectionIf("form", new HttpValuesCollection(Form)); w.WriteCollectionIf("cookies", new HttpValuesCollection(Cookie)); }
public void SaveTo(System.Xml.XmlWriter x) { x.WriteStartElement("BinaryPath"); x.WriteCData(BinPath); x.WriteEndElement(); foreach (var kv in LinkTargetConfigurations) { x.WriteStartElement("TargetConfiguration"); kv.Value.SaveTo(x); x.WriteEndElement(); } x.WriteStartElement("DefaultLibs"); foreach (var lib in DefaultLibraries) { x.WriteStartElement("lib"); x.WriteCData(lib); x.WriteEndElement(); } x.WriteEndElement(); x.WriteStartElement("Includes"); foreach (var inc in ParseCache.ParsedDirectories) { x.WriteStartElement("Path"); x.WriteCData(inc); x.WriteEndElement(); } x.WriteEndElement(); }
public void SaveTo(System.Xml.XmlWriter x) { x.WriteAttributeString("Target", TargetType.ToString()); x.WriteStartElement("CompilerCommand"); x.WriteCData(Compiler); x.WriteEndElement(); x.WriteStartElement("LinkerCommand"); x.WriteCData(Linker); x.WriteEndElement(); x.WriteStartElement("ObjectLinkPattern"); x.WriteCData(ObjectFileLinkPattern); x.WriteEndElement(); x.WriteStartElement("IncludePathPattern"); x.WriteCData(IncludePathPattern); x.WriteEndElement(); x.WriteStartElement("DebugArgs"); DebugArguments.SaveTo(x); x.WriteEndElement(); x.WriteStartElement("ReleaseArgs"); ReleaseArguments.SaveTo(x); x.WriteEndElement(); }
public void WriteTo (XmlWriter w) { w.WriteStartElement ("cmd"); w.WriteCData (DubCommand); w.WriteEndElement (); w.WriteStartElement ("commonargs"); w.WriteCData (CommonArgs); w.WriteEndElement (); }
public void WriteTo(XmlWriter x) { x.WriteStartElement("NACL_SDK_ROOT"); x.WriteCData(NACL_SDK_ROOT); x.WriteEndElement(); x.WriteStartElement("NACL_MONO_ROOT"); x.WriteCData(NACL_MONO_ROOT); x.WriteEndElement(); }
internal static void Save(XmlWriter x) { x.WriteStartElement("UnittestCommand"); x.WriteCData(UnittestCommand); x.WriteEndElement(); x.WriteStartElement("MainMethodFlag"); x.WriteCData(MainMethodFlag); x.WriteEndElement(); }
public void SaveTo(System.Xml.XmlWriter x) { x.WriteStartElement("CompilerArg"); x.WriteCData(CompilerArguments); x.WriteEndElement(); x.WriteStartElement("LinkerArgs"); x.WriteCData(LinkerArguments); x.WriteEndElement(); }
private void generateXml(XmlWriter writer) { writer.WriteStartDocument(); writer.WriteStartElement("results"); foreach (var runner in _results.GroupBy(x => x.Runner)) { writer.WriteStartElement("runner"); writer.WriteAttributeString("id", runner.Key); foreach (var assembly in runner.GroupBy(x => x.Assembly)) { writer.WriteStartElement("assembly"); writer.WriteAttributeString("name", assembly.Key); foreach (var fixture in assembly.GroupBy(x => x.TestFixture)) { writer.WriteStartElement("fixture"); writer.WriteAttributeString("name", fixture.Key); foreach (var test in fixture) { writer.WriteStartElement("test"); writer.WriteAttributeString("state", test.State.ToString()); writer.WriteAttributeString("name", test.TestName); if (test.TestDisplayName != null) writer.WriteAttributeString("displayName", test.TestDisplayName); writer.WriteAttributeString("duration", test.DurationInMilliseconds.ToString()); writer.WriteStartElement("message"); writer.WriteCData(test.Message); writer.WriteEndElement(); if (test.State == TestState.Failed || test.State == TestState.Ignored) { writer.WriteStartElement("stack-trace"); foreach (var line in test.StackLines) { writer.WriteStartElement("line"); writer.WriteStartElement("method"); writer.WriteCData(line.Method); writer.WriteEndElement(); writer.WriteStartElement("file"); writer.WriteAttributeString("line", line.Line.ToString()); writer.WriteRaw(line.File); writer.WriteEndElement(); writer.WriteEndElement(); } writer.WriteEndElement(); } writer.WriteEndElement(); } writer.WriteEndElement(); } writer.WriteEndElement(); } writer.WriteEndElement(); } writer.WriteEndElement(); }
public void SaveTo(XmlWriter x) { x.WriteStartElement ("CompilerArg"); x.WriteCData (CompilerArguments); x.WriteEndElement (); x.WriteStartElement ("LinkerArgs"); x.WriteCData (LinkerArguments); x.WriteEndElement (); x.WriteStartElement ("OneStepBuildArgs"); x.WriteCData (OneStepBuildArguments); x.WriteEndElement (); }
public void SaveTo(System.Xml.XmlWriter x) { x.WriteStartElement("BinaryPath"); x.WriteCData(BinPath); x.WriteEndElement(); x.WriteStartElement("VersionId"); x.WriteCData(PredefinedVersionConstant); x.WriteEndElement(); x.WriteStartElement("CompilerCommand"); x.WriteCData(SourceCompilerCommand); x.WriteEndElement(); x.WriteStartElement("Patterns"); ArgumentPatterns.SaveTo(x); x.WriteEndElement(); x.WriteStartElement("gdcLibPrefixing"); x.WriteString(EnableGDCLibPrefixing ? "true" : "false"); x.WriteEndElement(); foreach (var kv in LinkTargetConfigurations) { x.WriteStartElement("TargetConfiguration"); kv.Value.SaveTo(x); x.WriteEndElement(); } x.WriteStartElement("DefaultLibs"); foreach (var lib in DefaultLibraries) { x.WriteStartElement("lib"); x.WriteCData(lib); x.WriteEndElement(); } x.WriteEndElement(); x.WriteStartElement("Includes"); foreach (var inc in ParseCache.ParsedDirectories) { x.WriteStartElement("Path"); x.WriteCData(inc); x.WriteEndElement(); } x.WriteEndElement(); }
/// <summary> /// Write a string to an XmlWriter /// </summary> /// <param name="writer">the writer to write to</param> /// <param name="text">the string to write</param> /// <remarks> /// The test is escaped either using XML escape entities /// or using CDATA sections. /// </remarks> public static void WriteEscapedXmlString(XmlWriter writer, string text) { // Write either escaped text or CDATA sections int weightCData = 12 * (1 + CountSubstrings(text, CDATA_END)); int weightStringEscapes = 3*(CountSubstrings(text, "<") + CountSubstrings(text, ">")) + 4*CountSubstrings(text, "&"); if (weightStringEscapes <= weightCData) { // Write string using string escapes writer.WriteString(text); } else { // Write string using CDATA section int end = text.IndexOf(CDATA_END); if (end < 0) { writer.WriteCData(text); } else { int start = 0; while (end > -1) { writer.WriteCData(text.Substring(start, end - start)); if (end == text.Length - 3) { start = text.Length; writer.WriteString(CDATA_END); break; } else { writer.WriteString(CDATA_UNESCAPABLE_TOKEN); start = end + 2; end = text.IndexOf(CDATA_END, start); } } if (start < text.Length) { writer.WriteCData(text.Substring(start)); } } } }
protected override void FormatXml(XmlWriter writer, LoggingEvent loggingEvent) { writer.WriteStartElement("LogEntry"); writer.WriteStartElement("Level"); writer.WriteString(loggingEvent.Level.DisplayName); writer.WriteEndElement(); writer.WriteStartElement("Message"); writer.WriteCData(loggingEvent.RenderedMessage); writer.WriteEndElement(); writer.WriteStartElement("Details"); if (loggingEvent.ExceptionObject != null) writer.WriteCData(loggingEvent.ExceptionObject.ToString()); writer.WriteEndElement(); writer.WriteStartElement("StackTrace"); if (loggingEvent.ExceptionObject != null) { writer.WriteCData(string.IsNullOrEmpty(loggingEvent.ExceptionObject.StackTrace) ? string.Empty : loggingEvent.ExceptionObject.StackTrace); //Exception Details { // Get stack trace for the exception with source file information var st = new StackTrace(loggingEvent.ExceptionObject, true); // Get the top stack frame var frame = st.GetFrame(0); if (frame != null) { // Get the line number from the stack frame var line = frame.GetFileLineNumber(); string error_dtls = string.Format("\nFile: {0} -> Line:{1}", frame.GetFileName(), frame.GetFileLineNumber()); writer.WriteCData(error_dtls); } } writer.WriteEndElement(); } writer.WriteStartElement("TimeStamp"); writer.WriteString(loggingEvent.TimeStamp.ToString("dd/MM/yyyy HH:mm:ss")); writer.WriteEndElement(); writer.WriteEndElement(); }
protected override bool SerializeElement(XmlWriter writer, bool serializeCollectionKey) { if (writer != null) writer.WriteCData(Value); return true; }
/// <summary> /// Add authors. /// </summary> /// <param name="writer"> /// The writer. /// </param> private static void AddAuthors(XmlWriter writer) { writer.WriteStartElement("authors"); foreach (MembershipUser user in Membership.GetAllUsers()) { writer.WriteStartElement("author"); writer.WriteAttributeString("id", user.UserName); writer.WriteAttributeString( "date-created", user.CreationDate.ToString("yyyy-MM-ddTHH:mm:ss", CultureInfo.InvariantCulture)); writer.WriteAttributeString( "date-modified", user.CreationDate.ToString("yyyy-MM-ddTHH:mm:ss", CultureInfo.InvariantCulture)); writer.WriteAttributeString("approved", "true"); writer.WriteAttributeString("email", user.Email); writer.WriteStartElement("title"); writer.WriteAttributeString("type", "text"); writer.WriteCData(user.UserName); writer.WriteEndElement(); writer.WriteEndElement(); } writer.WriteEndElement(); }
private static void AddCategories(XmlWriter writer) { writer.WriteStartElement("categories"); foreach (Category category in Category.Categories) { writer.WriteStartElement("category"); writer.WriteAttributeString("id", category.Id.ToString()); writer.WriteAttributeString("date-created", category.DateCreated.ToString("yyyy-MM-ddTHH:mm:ss")); writer.WriteAttributeString("date-modified", category.DateModified.ToString("yyyy-MM-ddTHH:mm:ss")); writer.WriteAttributeString("approved", "true"); writer.WriteAttributeString("parentref", "0"); if (!String.IsNullOrEmpty(category.Description)) { writer.WriteAttributeString("description", category.Description); } writer.WriteStartElement("title"); writer.WriteAttributeString("type", "text"); writer.WriteCData(category.Title); writer.WriteEndElement(); writer.WriteEndElement(); } writer.WriteEndElement(); }
private static void WriteNode(XmlReader reader, XmlWriter writer) { while (reader.Read()) { switch (reader.NodeType) { case XmlNodeType.Element: writer.WriteStartElement(reader.Name); break; case XmlNodeType.Text: writer.WriteString(reader.Value); break; case XmlNodeType.CDATA: writer.WriteCData(reader.Value); break; case XmlNodeType.ProcessingInstruction: writer.WriteProcessingInstruction(reader.Name, reader.Value); break; case XmlNodeType.Comment: writer.WriteComment(reader.Value); break; case XmlNodeType.XmlDeclaration: break; case XmlNodeType.Document: break; case XmlNodeType.DocumentType: break; case XmlNodeType.EntityReference: break; case XmlNodeType.EndElement: writer.WriteEndElement(); break; } } }
protected override void Write(XmlWriter writer) { writer.WriteElementString("_type", "2"); writer.WriteStartElement("char"); writer.WriteCData(m_char.ToString()); writer.WriteEndElement(); }
public static void GravarLogAcesso() { List <string> logKeys = new List <string>(new string[] { "HTTP_USER_AGENT", "HTTP_REFERER", "QUERY_STRING", "REMOTE_ADDR" }); StringBuilder xml = new StringBuilder(); using (System.Xml.XmlWriter writer = System.Xml.XmlWriter.Create(xml)) { writer.WriteStartDocument(); writer.WriteStartElement("Dados"); foreach (string key in HttpContext.Current.Request.ServerVariables.AllKeys) { if (logKeys.Contains(key)) { writer.WriteStartElement("Item"); writer.WriteAttributeString("Key", key); writer.WriteCData(HttpContext.Current.Request.ServerVariables[key]); writer.WriteEndElement(); } } writer.WriteEndElement(); writer.WriteEndDocument(); } string atributo = xml.ToString().Replace("utf-16", "utf-8"); DatabaseUtil.Connector.BindSql("insert into log_acesso (cod_usuario, dat_acesso, dsc_atributo) values (?, ?, ?) "). ToParam("@Usuario", Convert.ToInt32(HttpContext.Current.Session["CodUsuario"])). ToParam("@Data", DateTime.Now). ToParam("@Atributo", atributo). Execute(); }
protected override void Write(XmlWriter writer) { writer.WriteElementString("_type", "0"); writer.WriteStartElement("text"); writer.WriteCData(m_text); writer.WriteEndElement(); }
public void WriteXml(System.Xml.XmlWriter writer) { foreach (KeyValue key in this.Keys) { writer.WriteStartElement("item"); //Write key writer.WriteStartElement("key"); writer.WriteStartElement("keyValue"); if (key.FunctionKey != null) { writer.WriteStartElement("functionKey"); writer.WriteString(key.FunctionKey.Value.ToString()); writer.WriteEndElement(); } if (key.String != null) { writer.WriteStartElement("str"); writer.WriteCData(key.String); writer.WriteEndElement(); } writer.WriteEndElement(); writer.WriteEndElement(); writer.WriteStartElement("value"); writer.WriteStartElement("ticks"); writer.WriteString(this[key]); writer.WriteEndElement(); writer.WriteEndElement(); writer.WriteEndElement(); } }
public void WriteXml(System.Xml.XmlWriter writer) { foreach (KeyValue key in this.Keys) { writer.WriteStartElement("item"); //Write key writer.WriteStartElement("key"); writer.WriteStartElement("keyValue"); if (key.FunctionKey != null) { writer.WriteStartElement("functionKey"); writer.WriteString(key.FunctionKey.Value.ToString()); writer.WriteEndElement(); } if (key.String != null) { writer.WriteStartElement("str"); writer.WriteCData(key.String); writer.WriteEndElement(); } writer.WriteEndElement(); writer.WriteEndElement(); //Write value (as ticks because TimeSpan is not XML serialisable) TimeSpan value = this[key]; writer.WriteStartElement("value"); writer.WriteStartElement("ticks"); writer.WriteString(XmlConvert.ToString(value)); writer.WriteEndElement(); writer.WriteEndElement(); writer.WriteEndElement(); } }
/// <summary> /// Writes the contents of this configuration element to the configuration file when implemented in a derived class. /// </summary> /// <param name="writer">The <see cref="T:System.Xml.XmlWriter"/> that writes to the configuration file.</param> /// <param name="serializeCollectionKey">true to serialize only the collection key properties; otherwise, false.</param> /// <returns> /// true if any data was actually serialized; otherwise, false. /// </returns> /// <exception cref="T:System.Configuration.ConfigurationErrorsException"> /// The current attribute is locked at a higher configuration level. /// </exception> protected override bool SerializeElement(System.Xml.XmlWriter writer, bool serializeCollectionKey) { bool returnValue; if (string.IsNullOrEmpty(cDataConfigurationPropertyName)) { returnValue = base.SerializeElement(writer, serializeCollectionKey); } else { foreach (ConfigurationProperty configurationProperty in Properties) { string name = configurationProperty.Name; TypeConverter converter = configurationProperty.Converter; string propertyValue = converter.ConvertToString(base[name]); if (writer != null) { if (name == cDataConfigurationPropertyName) { writer.WriteCData(propertyValue); } else { writer.WriteAttributeString("name", propertyValue); } } } returnValue = true; } return(returnValue); }
public void WriteXml(System.Xml.XmlWriter writer) { writer.WriteAttributeString("src", src); if (!System.String.IsNullOrEmpty(Value)) { writer.WriteCData(Value); } }
protected override bool SerializeToXmlElement(XmlWriter writer, string elementName) { if (writer == null) return true; writer.WriteStartElement(elementName); writer.WriteCData(Sql); writer.WriteEndElement(); return false; }
private void WriteDirectValue(CommenceValue v) { _xw.WriteStartElement(XmlConvert.EncodeLocalName(base.ExportHeaders[v.ColumnDefinition.ColumnIndex])); // only write if we have something if (!string.IsNullOrEmpty(v.DirectFieldValue)) { // can we get away with writing the value or do we need to use CData? if (v.ColumnDefinition.CommenceFieldDefinition.MaxChars == CommenceLimits.MaxTextFieldCapacity) { _xw.WriteCData(v.DirectFieldValue); } else { _xw.WriteString(v.DirectFieldValue); } } _xw.WriteEndElement(); }
public bool writeCdata(string content) { if (_state.Count != 0 && _state.Peek() != State.PI) { PhpException.Throw(PhpError.Warning, Resources.XmlWritterCDataWrongContext); return(false); } return(CheckedCall(() => _writer.WriteCData(content))); }
/// <summary> /// Write xml /// </summary> /// <param name="writer">Writer</param> public void WriteXml(System.Xml.XmlWriter writer) { if (string.IsNullOrWhiteSpace(value)) { writer.WriteString(string.Empty); } else { writer.WriteCData("\n" + value + "\n"); } }
public void WriteXml(System.Xml.XmlWriter writer) { writer.WriteElementString("Key", this.Key); writer.WriteElementString("Expire", this.Expire.HasValue ? this.Expire.Value.ToString("yyyy-MM-dd HH:mm:ss") : ""); writer.WriteStartElement("Value"); var valueType = Value.GetType(); var assemblyName = valueType.Assembly.FullName.Split(',')[0]; writer.WriteAttributeString("Type", string.Format("{0},{1}", valueType.FullName, assemblyName)); writer.WriteCData(string.Format("{0}", XmlSerialize.SerializeToString(this.Value))); writer.WriteEndElement(); }
void writeFields(UniFields fields, XmlWriter writer) { writer.WriteStartElement("fields"); foreach (String str in fields.Keys) { writer.WriteStartElement("field"); writer.WriteAttributeString("name", str); writer.WriteAttributeString("type", fields[str].Type.ToString()); writer.WriteCData(fields[str].Value.ToString()); writer.WriteEndElement(); } writer.WriteEndElement(); }
public void Save(XmlWriter x) { x.WriteStartDocument(); x.WriteStartElement("ResourceFileBinding"); x.WriteStartElement("CompilerPath"); x.WriteCData(ResourceCompilerPath); x.WriteEndElement(); x.WriteStartElement("CompilerArguments"); x.WriteCData(ResourceCompilerArguments); x.WriteEndElement(); /* x.WriteStartElement("BracketHightlighting"); x.WriteAttributeString("value", EnableMatchingBracketHighlighting.ToString().ToLower()); x.WriteEndElement(); */ x.WriteEndElement(); }
public static void write(XmlWriter writer, LuaScript[] scripts) { writer.WriteStartElement("scripts"); foreach (LuaScript lua in scripts) { writer.WriteStartElement("script"); writer.WriteAttributeString("name", lua.Name); writer.WriteAttributeString("tag", lua.Tag.ToString()); writer.WriteCData(lua.Code); writer.WriteEndElement(); } writer.WriteEndElement(); }
private static void WriteKey(string key, ILocalizationDictionary dictionary, XmlWriter writer) { writer.WriteStartElement("key"); writer.WriteAttributeString("id", key); foreach(var locale in dictionary.Locales) { var value = dictionary[locale, key]; if(value==null) continue; writer.WriteStartElement("val"); writer.WriteAttributeString("for", locale); writer.WriteCData(value); writer.WriteEndElement(); } writer.WriteEndElement(); }
public void WriteXml(System.Xml.XmlWriter writer) { foreach (string key in properties.Keys) { writer.WriteStartElement("item"); writer.WriteAttributeString("key", key); writer.WriteCData(this[key]); writer.WriteEndElement(); } }
private static void WriteShallowNode(XmlReader reader, XmlWriter writer) { switch (reader.NodeType) { case XmlNodeType.Element: writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI); writer.WriteAttributes(reader, true); if (reader.IsEmptyElement) { writer.WriteEndElement(); } return; case XmlNodeType.Text: writer.WriteString(reader.Value); return; case XmlNodeType.CDATA: writer.WriteCData(reader.Value); return; case XmlNodeType.ProcessingInstruction: writer.WriteProcessingInstruction(reader.Name, reader.Value); return; case XmlNodeType.Comment: writer.WriteComment(reader.Value); return; case XmlNodeType.DocumentType: writer.WriteDocType(reader.Name, reader.GetAttribute("PUBLIC"), reader.GetAttribute("SYSTEM"), reader.Value); return; case XmlNodeType.Whitespace: writer.WriteWhitespace(reader.Value); return; case XmlNodeType.SignificantWhitespace: writer.WriteWhitespace(reader.Value); return; case XmlNodeType.EndElement: writer.WriteFullEndElement(); return; case XmlNodeType.XmlDeclaration: writer.WriteProcessingInstruction(reader.Name, reader.Value); return; } throw new InvalidOperationException("Invalid node"); }
/// <summary> /// Write a string to an <see cref="XmlWriter"/> /// </summary> /// <param name="writer">the writer to write to</param> /// <param name="textData">the string to write</param> /// <param name="invalidCharReplacement">The string to replace non XML compliant chars with</param> /// <remarks> /// <para> /// The test is escaped either using XML escape entities /// or using CDATA sections. /// </para> /// </remarks> public static void WriteEscapedXmlString(XmlWriter writer, string textData, string invalidCharReplacement) { string stringData = MaskXmlInvalidCharacters(textData, invalidCharReplacement); // Write either escaped text or CDATA sections int weightCData = 12 * (1 + CountSubstrings(stringData, CDATA_END)); int weightStringEscapes = 3 * (CountSubstrings(stringData, "<") + CountSubstrings(stringData, ">")) + 4 * CountSubstrings(stringData, "&"); if (weightStringEscapes <= weightCData) { // Write string using string escapes writer.WriteString(stringData); } else { // Write string using CDATA section int end = stringData.IndexOf(CDATA_END); if (end < 0) { writer.WriteCData(stringData); } else { int start = 0; while (end > -1) { writer.WriteCData(stringData.Substring(start, end - start)); if (end == stringData.Length - 3) { start = stringData.Length; writer.WriteString(CDATA_END); break; } else { writer.WriteString(CDATA_UNESCAPABLE_TOKEN); start = end + 2; end = stringData.IndexOf(CDATA_END, start); } } if (start < stringData.Length) { writer.WriteCData(stringData.Substring(start)); } } } }
private void WriteExceptionXml(XmlWriter writer, Exception e) { writer.WriteElementString("message", e.Message); writer.WriteElementString("source", e.Source); writer.WriteStartElement("stack-trace"); writer.WriteCData(e.StackTrace); writer.WriteEndElement(); if (e.InnerException != null) { writer.WriteStartElement("inner-exception"); WriteExceptionXml(writer, e.InnerException); writer.WriteEndElement(); } }
public void WriteXml(System.Xml.XmlWriter writer) { writer.WriteStartElement("RequestTemplates"); foreach (string request in request_templates) { writer.WriteStartElement("Request"); writer.WriteCData(request); writer.WriteEndElement(); } writer.WriteEndElement(); writer.WriteElementString("URL", URL); writer.WriteElementString("SearchDateBeginInterval", SearchDateBeginInterval.ToString()); writer.WriteElementString("SearchDateEndInterval", SearchDateEndInterval.ToString()); writer.WriteElementString("ShowResponse", ShowResponse.ToString()); }
void IXmlSerializable.WriteXml(XmlWriter writer) { Regex regExHTML = new Regex(@"<(\w|-|_)+>(.)*<\/(\w)+>"); writer.WriteAttributeString("FieldName", this.FieldName); // If the content is HTML-like, use a CDATA section if (regExHTML.IsMatch(this.Value)) { writer.WriteCData(this.Value); } else { writer.WriteString(this.Value); } }
public void SaveTo(System.Xml.XmlWriter x) { x.WriteAttributeString("Target", TargetType.ToString()); x.WriteStartElement("LinkerCommand"); x.WriteCData(Linker); x.WriteEndElement(); x.WriteStartElement("DebugArgs"); DebugArguments.SaveTo(x); x.WriteEndElement(); x.WriteStartElement("ReleaseArgs"); ReleaseArguments.SaveTo(x); x.WriteEndElement(); }
public void Save(XmlWriter x) { x.WriteStartDocument(); x.WriteStartElement("dsettings"); x.WriteStartElement("cv2pdb"); x.WriteCData(cv2pdb_exe); x.WriteEndElement(); x.WriteStartElement("BracketHightlighting"); x.WriteAttributeString("value", EnableMatchingBracketHighlighting.ToString().ToLower()); x.WriteEndElement(); x.WriteStartElement("UseCodeCompletion"); x.WriteAttributeString("value",UseCodeCompletion.ToString().ToLower()); x.WriteEndElement(); x.WriteStartElement("UseMethodInsight"); x.WriteAttributeString("value", UseMethodInsight.ToString().ToLower()); x.WriteEndElement(); x.WriteStartElement("ForceCodeCompetionPopupCommit"); x.WriteAttributeString("value", ForceCodeCompetionPopupCommit. ToString().ToLower()); x.WriteEndElement(); x.WriteStartElement("UseSemanticErrorHighlighting"); x.WriteAttributeString("value", UseSemanticErrorHighlighting.ToString().ToLower()); x.WriteEndElement(); x.WriteStartElement("UseSemanticHighlighting"); x.WriteAttributeString("value", UseSemanticHighlighting.ToString().ToLower()); x.WriteEndElement(); x.WriteStartElement("SmartIndentation"); x.WriteAttributeString("value", EnableSmartIndentation. ToString().ToLower()); x.WriteEndElement(); x.WriteStartElement("CompletionOptions"); CompletionOptions.Instance.Save(x); x.WriteEndElement(); dmd1.Save(x); dmd2.Save(x); x.WriteEndElement(); }
public override void WriteTo (XmlWriter writer) { int start = 0; StringBuilder sb = null; for (int i = 0; i < Value.Length - 2; i++) { if (Value [i] == ']' && Value [i + 1] == ']' && Value [i + 2] == '>') { if (sb == null) sb = new StringBuilder (); sb.Append (Value, start, i - start); sb.Append ("]]>"); start = i + 3; } } if (start != 0 && start != Value.Length) sb.Append (Value, start, Value.Length - start); writer.WriteCData (sb == null ? Value : sb.ToString ()); }
protected override void WriteElementContent(XmlWriter writer) { if (!string.IsNullOrEmpty(_text)) { if (_type == null || _type.Value == null) { writer.WriteString(_text); return; } if (Helper.IsXmlType(_type)) { writer.WriteRaw(_text); } else if (_type == AtomContentType.Html) { writer.WriteCData(_text); } else { writer.WriteString(_text); } } }
/// <summary> /// Writes an XmlElement using cdata text and optional attributes /// </summary> /// <param name="writer">The writer to use</param> /// <param name="name">The name of the element</param> /// <param name="cdataText">The cdata text value of the element</param> /// <param name="attributes">The attributes for the element</param> public static void WriteCDataElement(XmlWriter writer, string name, string cdataText, params XmlStringPair[] attributes) { Debug.Assert(writer != null); // if the element will have data if (XmlWriterUtils.IsNeeded(cdataText)) { // start the element writer.WriteStartElement(name); // write the attributes XmlWriterUtils.WriteAttributes(writer, attributes); // write the cdata text value writer.WriteCData(cdataText); // end the element writer.WriteEndElement(); } }
public void WriteXml(System.Xml.XmlWriter writer) { writer.WriteCData(Value); }
// Writes the content (inner XML) of the current node into the provided XmlWriter. private async Task WriteNodeAsync(XmlWriter xtw, bool defattr) { #if !SILVERLIGHT Debug.Assert(xtw is XmlTextWriter); #endif int d = this.NodeType == XmlNodeType.None ? -1 : this.Depth; while (await this.ReadAsync().ConfigureAwait(false) && (d < this.Depth)) { switch (this.NodeType) { case XmlNodeType.Element: xtw.WriteStartElement(this.Prefix, this.LocalName, this.NamespaceURI); #if !SILVERLIGHT // Removing dependency on XmlTextWriter ((XmlTextWriter)xtw).QuoteChar = this.QuoteChar; #endif xtw.WriteAttributes(this, defattr); if (this.IsEmptyElement) { xtw.WriteEndElement(); } break; case XmlNodeType.Text: xtw.WriteString(await this.GetValueAsync().ConfigureAwait(false)); break; case XmlNodeType.Whitespace: case XmlNodeType.SignificantWhitespace: xtw.WriteWhitespace(await this.GetValueAsync().ConfigureAwait(false)); break; case XmlNodeType.CDATA: xtw.WriteCData(this.Value); break; case XmlNodeType.EntityReference: xtw.WriteEntityRef(this.Name); break; case XmlNodeType.XmlDeclaration: case XmlNodeType.ProcessingInstruction: xtw.WriteProcessingInstruction(this.Name, this.Value); break; case XmlNodeType.DocumentType: xtw.WriteDocType(this.Name, this.GetAttribute("PUBLIC"), this.GetAttribute("SYSTEM"), this.Value); break; case XmlNodeType.Comment: xtw.WriteComment(this.Value); break; case XmlNodeType.EndElement: xtw.WriteFullEndElement(); break; } } if (d == this.Depth && this.NodeType == XmlNodeType.EndElement) { await ReadAsync().ConfigureAwait(false); } }
protected override void WriteContentsTo(System.Xml.XmlWriter writer) { writer.WriteCData(Text); }
/// <summary> /// Persists a localization file into an XML format. /// </summary> /// <param name="writer">XmlWriter where the localization file should persist itself as XML.</param> public void Persist(XmlWriter writer) { writer.WriteStartElement(Localization.XmlElementName, XmlNamespaceUri); if (-1 != this.codepage) { writer.WriteAttributeString("Codepage", this.codepage.ToString(CultureInfo.InvariantCulture)); } if (!String.IsNullOrEmpty(this.culture)) { writer.WriteAttributeString("Culture", this.culture); } foreach (WixVariableRow wixVariableRow in this.variables.Values) { writer.WriteStartElement("String", XmlNamespaceUri); writer.WriteAttributeString("Id", wixVariableRow.Id); if (wixVariableRow.Overridable) { writer.WriteAttributeString("Overridable", "yes"); } writer.WriteCData(wixVariableRow.Value); writer.WriteEndElement(); } foreach (string controlKey in this.localizedControls.Keys) { writer.WriteStartElement("UI", XmlNamespaceUri); string[] controlKeys = controlKey.Split('/'); string dialog = controlKeys[0]; string control = controlKeys[1]; if (!String.IsNullOrEmpty(dialog)) { writer.WriteAttributeString("Dialog", dialog); } if (!String.IsNullOrEmpty(control)) { writer.WriteAttributeString("Control", control); } LocalizedControl localizedControl = this.localizedControls[controlKey]; if (CompilerCore.IntegerNotSet != localizedControl.X) { writer.WriteAttributeString("X", localizedControl.X.ToString()); } if (CompilerCore.IntegerNotSet != localizedControl.Y) { writer.WriteAttributeString("Y", localizedControl.Y.ToString()); } if (CompilerCore.IntegerNotSet != localizedControl.Width) { writer.WriteAttributeString("Width", localizedControl.Width.ToString()); } if (CompilerCore.IntegerNotSet != localizedControl.Height) { writer.WriteAttributeString("Height", localizedControl.Height.ToString()); } if (MsiInterop.MsidbControlAttributesRTLRO == (localizedControl.Attributes & MsiInterop.MsidbControlAttributesRTLRO)) { writer.WriteAttributeString("RightToLeft", "yes"); } if (MsiInterop.MsidbControlAttributesRightAligned == (localizedControl.Attributes & MsiInterop.MsidbControlAttributesRightAligned)) { writer.WriteAttributeString("RightAligned", "yes"); } if (MsiInterop.MsidbControlAttributesLeftScroll == (localizedControl.Attributes & MsiInterop.MsidbControlAttributesLeftScroll)) { writer.WriteAttributeString("LeftScroll", "yes"); } if (!String.IsNullOrEmpty(localizedControl.Text)) { writer.WriteCData(localizedControl.Text); } writer.WriteEndElement(); } writer.WriteEndElement(); }
public override void WriteCData(string text) { CheckAsync(); _coreWriter.WriteCData(text); }
public override void WriteCData(string text) { _writer.WriteCData(text); }
public override void WriteCData(string?text) { _wrapped.WriteCData(text); }
public override void WriteCData(string text) { writer.WriteCData(text); state = WriteState.Content; }
protected override void DoWrite(Node node) { switch (node.Type) { case NodeType.DocumentStart: case NodeType.DocumentEnd: // nada a fazer break; case NodeType.ObjectStart: { var parentKind = stack.FirstOrDefault(); var parentIsProperty = parentKind == NodeType.Property; if (!parentIsProperty) { var name = (node.Value ?? "Element").ToString(); var tagName = ValueConventions.CreateName(name, Settings, TextCase.PascalCase); writer.WriteStartElement(tagName); } stack.Push(NodeType.Object); break; } case NodeType.ObjectEnd: { stack.Pop(); var parentKind = stack.FirstOrDefault(); var parentIsProperty = parentKind == NodeType.Property; if (!parentIsProperty) { writer.WriteEndElement(); } break; } case NodeType.CollectionStart: { var parentKind = stack.FirstOrDefault(); var parentIsProperty = parentKind == NodeType.Property; if (!parentIsProperty) { var name = (node.Value ?? "Array").ToString(); var tagName = ValueConventions.CreateName(name, Settings, TextCase.PascalCase); writer.WriteStartElement(tagName); } var attName = ValueConventions.CreateName("IsArray", Settings, TextCase.PascalCase); writer.WriteAttributeString(attName, "true"); stack.Push(NodeType.Collection); break; } case NodeType.CollectionEnd: { stack.Pop(); var parentKind = stack.FirstOrDefault(); var parentIsProperty = parentKind == NodeType.Property; if (!parentIsProperty) { writer.WriteEndElement(); } break; } case NodeType.PropertyStart: { var name = (node.Value ?? "Property").ToString(); var tagName = ValueConventions.CreateName(name, Settings, TextCase.PascalCase); writer.WriteStartElement(tagName); stack.Push(NodeType.Property); break; } case NodeType.PropertyEnd: { writer.WriteEndElement(); stack.Pop(); break; } case NodeType.Value: { if (node.Value == null) { writer.WriteValue(null); } else if (node.Value is XContainer) { var xml = (XContainer)node.Value; var cdata = xml.ToString(SaveOptions.DisableFormatting); writer.WriteCData(cdata); } else { var text = ValueConventions.CreateText(node.Value, Settings); writer.WriteValue(text); } break; } default: throw new SerializationException("Token não esperado: " + node); } if (Settings.AutoFlush) { DoFlush(); } }
public override void WriteTo(XmlWriter w) { w.WriteCData(this.Data); }
public override void WriteCData(string text) { CheckState(); w.WriteCData(text); }
public void Save(XmlWriter x) { x.WriteStartElement ("exe"); x.WriteCData (Executable); x.WriteEndElement (); x.WriteStartElement ("args"); x.WriteCData (Arguments); x.WriteEndElement (); }
public void WriteTo(XmlWriter x) { x.WriteStartElement ("DefaultCompiler"); x.WriteString (DefaultCompiler); x.WriteEndElement (); foreach (var cmp in Compilers) { x.WriteStartElement ("Compiler"); x.WriteAttributeString ("Name", cmp.Vendor); cmp.SaveTo (x); x.WriteEndElement (); } x.WriteStartElement ("ResCmp"); Win32ResourceCompiler.Instance.Save (x); x.WriteEndElement (); x.WriteStartElement ("DDocBaseUrl"); x.WriteCData (D.Refactoring.DDocumentationLauncher.DigitalMarsUrl); x.WriteEndElement (); x.WriteStartElement ("CompletionOptions"); CompletionOptions.Save (x); x.WriteEndElement (); x.WriteStartElement("DocumentOutline"); Outline.Save(x); x.WriteEndElement(); x.WriteStartElement("FormattingCorrectsIndentOnly"); x.WriteString(Formatting.DCodeFormatter.IndentCorrectionOnly ? "true" : "false"); x.WriteEndElement(); }
/// <summary> /// Replay all cached events to an XmlWriter. /// </summary> public void EventsToWriter(XmlWriter writer) { XmlEvent[] page; int idxPage, idxEvent; byte[] bytes; char[] chars; XmlRawWriter rawWriter; // Special-case single text node at the top-level if (this.singleText.Count != 0) { writer.WriteString(this.singleText.GetResult()); return; } rawWriter = writer as XmlRawWriter; // Loop over set of pages for (idxPage = 0; idxPage < this.pages.Count; idxPage++) { page = this.pages[idxPage]; // Loop over events in each page for (idxEvent = 0; idxEvent < page.Length; idxEvent++) { switch (page[idxEvent].EventType) { case XmlEventType.Unknown: // No more events Debug.Assert(idxPage + 1 == this.pages.Count); return; case XmlEventType.DocType: writer.WriteDocType(page[idxEvent].String1, page[idxEvent].String2, page[idxEvent].String3, (string)page[idxEvent].Object); break; case XmlEventType.StartElem: writer.WriteStartElement(page[idxEvent].String1, page[idxEvent].String2, page[idxEvent].String3); break; case XmlEventType.StartAttr: writer.WriteStartAttribute(page[idxEvent].String1, page[idxEvent].String2, page[idxEvent].String3); break; case XmlEventType.EndAttr: writer.WriteEndAttribute(); break; case XmlEventType.CData: writer.WriteCData(page[idxEvent].String1); break; case XmlEventType.Comment: writer.WriteComment(page[idxEvent].String1); break; case XmlEventType.PI: writer.WriteProcessingInstruction(page[idxEvent].String1, page[idxEvent].String2); break; case XmlEventType.Whitespace: writer.WriteWhitespace(page[idxEvent].String1); break; case XmlEventType.String: writer.WriteString(page[idxEvent].String1); break; case XmlEventType.Raw: writer.WriteRaw(page[idxEvent].String1); break; case XmlEventType.EntRef: writer.WriteEntityRef(page[idxEvent].String1); break; case XmlEventType.CharEnt: writer.WriteCharEntity((char)page[idxEvent].Object); break; case XmlEventType.SurrCharEnt: chars = (char[])page[idxEvent].Object; writer.WriteSurrogateCharEntity(chars[0], chars[1]); break; case XmlEventType.Base64: bytes = (byte[])page[idxEvent].Object; writer.WriteBase64(bytes, 0, bytes.Length); break; case XmlEventType.BinHex: bytes = (byte[])page[idxEvent].Object; writer.WriteBinHex(bytes, 0, bytes.Length); break; case XmlEventType.XmlDecl1: if (rawWriter != null) { rawWriter.WriteXmlDeclaration((XmlStandalone)page[idxEvent].Object); } break; case XmlEventType.XmlDecl2: if (rawWriter != null) { rawWriter.WriteXmlDeclaration(page[idxEvent].String1); } break; case XmlEventType.StartContent: if (rawWriter != null) { rawWriter.StartElementContent(); } break; case XmlEventType.EndElem: if (rawWriter != null) { rawWriter.WriteEndElement(page[idxEvent].String1, page[idxEvent].String2, page[idxEvent].String3); } else { writer.WriteEndElement(); } break; case XmlEventType.FullEndElem: if (rawWriter != null) { rawWriter.WriteFullEndElement(page[idxEvent].String1, page[idxEvent].String2, page[idxEvent].String3); } else { writer.WriteFullEndElement(); } break; case XmlEventType.Nmsp: if (rawWriter != null) { rawWriter.WriteNamespaceDeclaration(page[idxEvent].String1, page[idxEvent].String2); } else { writer.WriteAttributeString("xmlns", page[idxEvent].String1, XmlReservedNs.NsXmlNs, page[idxEvent].String2); } break; case XmlEventType.EndBase64: if (rawWriter != null) { rawWriter.WriteEndBase64(); } break; case XmlEventType.Close: writer.Close(); break; case XmlEventType.Flush: writer.Flush(); break; case XmlEventType.Dispose: ((IDisposable)writer).Dispose(); break; default: Debug.Assert(false, "Unknown event: " + page[idxEvent].EventType); break; } } } Debug.Assert(false, "Unknown event should be added to end of event sequence."); }
/// <summary> /// Write element text /// </summary> /// <param name="writer">XML writer</param> protected override void WriteText(XmlWriter writer) { string text = Utils.To<string>(Value); if (text != null) { text = text.Trim() + Environment.NewLine; if (text.Length > 0) { if (text.IndexOfAny("><&".ToCharArray()) != -1) { if (!text.Contains("?>")) writer.WriteProcessingInstruction("_", text); else writer.WriteCData(text); } else writer.WriteValue(text); } } }
public bool writeCdata(string content) => CheckedCall(() => _writer.WriteCData(content));