/// <summary> /// Creates XML elements from the data of the system. /// </summary> /// <param name="xmlWriter">Object with the XML message to add new information and return to client side</param> /// <param name="val">Value to be puted inside the XML message</param> /// <param name="dtdVersion">Version of the DTD that follows the XML message</param> /// <param name="xmlElement">Element of the XML that is checked</param> public static void ON2XML(XmlWriter xmlWriter, ONBool val, double dtdVersion, string xmlElement) { if (val == null) { if (xmlElement == ONXml.XMLTAG_V) xmlWriter.WriteElementString(xmlElement, ""); else xmlWriter.WriteElementString(ONXml.XMLTAG_NULL, null); } else { if (dtdVersion < 2.0) // Apply the locale format { if (val.TypedValue) xmlWriter.WriteElementString(xmlElement, "Verdadero"); else xmlWriter.WriteElementString(xmlElement, "Falso"); } else { xmlWriter.WriteStartElement(xmlElement); if (xmlElement == ONXml.XMLTAG_OIDFIELD && dtdVersion > 2.0) xmlWriter.WriteAttributeString("Type", "bool"); if (val.TypedValue) xmlWriter.WriteString("true"); else xmlWriter.WriteString("false"); xmlWriter.WriteEndElement(); } } }
/// <summary> /// Creates XML elements from the data of the system. /// </summary> /// <param name="xmlWriter">Object with the XML message to add new information and return to client side</param> /// <param name="val">Value to be puted inside the XML message</param> /// <param name="dtdVersion">Version of the DTD that follows the XML message</param> /// <param name="xmlElement">Element of the XML that is checked</param> public static void ON2XML(XmlWriter xmlWriter, ONDateTime val, double dtdVersion, string xmlElement) { if (val == null) { if (xmlElement == ONXml.XMLTAG_V) xmlWriter.WriteElementString(xmlElement, ""); else xmlWriter.WriteElementString(ONXml.XMLTAG_NULL, null); } else { if (dtdVersion < 2.0) // Apply the locale format xmlWriter.WriteElementString(xmlElement, val.TypedValue.ToString()); else { xmlWriter.WriteStartElement(xmlElement); if (xmlElement == ONXml.XMLTAG_OIDFIELD && dtdVersion > 2.0) xmlWriter.WriteAttributeString("Type", "datetime"); if (val.TypedValue.Millisecond == 0) xmlWriter.WriteString(val.TypedValue.ToString("yyyy-MM-ddTHH:mm:ss")); else xmlWriter.WriteString(val.TypedValue.ToString("yyyy-MM-ddTHH:mm:ss.fff")); xmlWriter.WriteEndElement(); } } }
private static void WriteXmlInnerError(XmlWriter writer, ODataInnerError innerError, string innerErrorElementName, int recursionDepth, int maxInnerErrorDepth) { recursionDepth++; if (recursionDepth > maxInnerErrorDepth) { throw new ODataException(Strings.ValidationUtils_RecursionDepthLimitReached(maxInnerErrorDepth)); } writer.WriteStartElement("m", innerErrorElementName, "http://schemas.microsoft.com/ado/2007/08/dataservices/metadata"); string text = innerError.Message ?? string.Empty; writer.WriteStartElement("message", "http://schemas.microsoft.com/ado/2007/08/dataservices/metadata"); writer.WriteString(text); writer.WriteEndElement(); string str2 = innerError.TypeName ?? string.Empty; writer.WriteStartElement("type", "http://schemas.microsoft.com/ado/2007/08/dataservices/metadata"); writer.WriteString(str2); writer.WriteEndElement(); string str3 = innerError.StackTrace ?? string.Empty; writer.WriteStartElement("stacktrace", "http://schemas.microsoft.com/ado/2007/08/dataservices/metadata"); writer.WriteString(str3); writer.WriteEndElement(); if (innerError.InnerError != null) { WriteXmlInnerError(writer, innerError.InnerError, "internalexception", recursionDepth, maxInnerErrorDepth); } writer.WriteEndElement(); }
/// <summary> /// If the XmlDebugging property is set to true, writes a BytesRead /// node to the DebugXmlWriter containing a hexadecimal representation /// of the supplied byte array. /// If the XmlDebugging property is set to false, does nothing. /// </summary> /// <param name="elementName">The name of the element to write</param> /// <param name="bytes">The byte array to write</param> /// <exception cref="ArgumentNullException"> /// The supplied byte array is null. /// </exception> protected void WriteDebugXmlByteValues(string elementName, int[] bytes) { if (bytes == null) { throw new ArgumentNullException("bytes"); } if (_xmlDebugging) { _debugXmlWriter.WriteStartElement(elementName); StringBuilder sb = new StringBuilder(); for (int i = 0; i < bytes.Length; i++) { sb.Append(ToHex(bytes[i]) + " "); int result; Math.DivRem(i + 1, 16, out result); if (result == 0) { _debugXmlWriter.WriteStartElement("ByteGroup"); _debugXmlWriter.WriteString(sb.ToString()); _debugXmlWriter.WriteEndElement(); sb = new StringBuilder(); } } _debugXmlWriter.WriteStartElement("ByteGroup"); _debugXmlWriter.WriteString(sb.ToString()); _debugXmlWriter.WriteEndElement(); _debugXmlWriter.WriteEndElement(); } }
/// <summary> /// Converts the object to its xml representation. /// </summary> /// <param name="writer">The <see cref="T:System.Xml.XmlWriter" />-stream, to which the object is serialized.</param> public void WriteXml(System.Xml.XmlWriter writer) { CurveTypeEnum?CT = GetCurveTypeEnum(); //writer.WriteStartElement(GetType().ToString()); writer.WriteStartElement("Name"); writer.WriteString(Name); writer.WriteEndElement(); writer.WriteStartElement("Curve"); if (CT.HasValue) { writer.WriteString(CT.ToString()); } else { StringBuilder S = new StringBuilder(); for (int i = 0; i < 256; i++) { S.AppendFormat("{0}, ", Data[i]); } writer.WriteString(S.ToString().Substring(0, S.Length - 2)); } writer.WriteEndElement(); // writer.WriteEndElement(); }
internal override void WriteXml(XmlWriter writer) { if (base.IsSlot) { writer.WriteStartElement("Property", NodeQuery.XmlNamespace); writer.WriteAttributeString("name", base.PropertySlot.Name); writer.WriteEndElement(); } else if (!IsValue) { writer.WriteStartElement("Property", NodeQuery.XmlNamespace); writer.WriteAttributeString("name", base.NodeAttribute.ToString()); writer.WriteEndElement(); } else { if (_value == null) writer.WriteElementString("NullValue", NodeQuery.XmlNamespace, null); else if (_value is string) writer.WriteString((string)_value); else if (_value is int) writer.WriteString(XmlConvert.ToString((int)_value)); else if (_value is decimal) writer.WriteString(XmlConvert.ToString((decimal)_value)); if (_value is DateTime) writer.WriteString(XmlConvert.ToString((DateTime)_value, XmlDateTimeSerializationMode.Unspecified)); } }
public void Render(System.Xml.XmlWriter writer) { writer.WriteStartElement("", "Customer", "mvp-xml-templates"); writer.WriteAttributeString("", "xmlns", "http://www.w3.org/2000/xmlns/", "mvp-xml-templates"); writer.WriteAttributeString("", "FullName", "", Converter.ToString(Customer.LastName + ", " + Customer.FirstName)); foreach (Order o in this.Customer.Orders) //; { writer.WriteStartElement("", "Order", "mvp-xml-templates"); writer.WriteAttributeString("", "Id", "", Converter.ToString(o.Id)); writer.WriteAttributeString("", "Premium", "", Converter.ToString(CalculateTotal(o) > 5000)); writer.WriteAttributeString("", "Date", "", Converter.ToString(o.DateOrdered)); writer.WriteStartElement("", "GrandTotal", "mvp-xml-templates"); writer.WriteString(Converter.ToString(CalculateTotal(o))); writer.WriteEndElement(); if (o.Items != null) //; { foreach (Item i in o.Items) //; { writer.WriteStartElement("", "Item", "mvp-xml-templates"); writer.WriteAttributeString("", "Id", "", Converter.ToString(i.ProductId)); writer.WriteAttributeString("", "SubTotal", "", Converter.ToString(i.Quantity * i.Price)); writer.WriteStartElement("", "Quantity", "mvp-xml-templates"); writer.WriteString(Converter.ToString(i.Quantity)); writer.WriteEndElement(); writer.WriteStartElement("", "Price", "mvp-xml-templates"); writer.WriteString(Converter.ToString(i.Price)); writer.WriteEndElement(); writer.WriteEndElement(); } //; } //; writer.WriteEndElement(); } //; writer.WriteEndElement(); }
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.WriteString(loggingEvent.RenderedMessage); writer.WriteEndElement(); writer.WriteStartElement("Details"); if (loggingEvent.ExceptionObject != null) writer.WriteString(loggingEvent.ExceptionObject.ToString()); writer.WriteEndElement(); writer.WriteStartElement("StackTrace"); if (loggingEvent.ExceptionObject != null) writer.WriteString(string.IsNullOrEmpty(loggingEvent.ExceptionObject.StackTrace) ? string.Empty : loggingEvent.ExceptionObject.StackTrace); writer.WriteEndElement(); writer.WriteStartElement("TimeStamp"); writer.WriteString(loggingEvent.TimeStamp.ToString("dd/MM/yyyy HH:mm:ss")); 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(); } }
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) { writer.WriteElementString("aggregate", Aggregate.ToString().ToLowerInvariant()); if (Assemblies != null) { writer.WriteStartElement("assemblies"); foreach (var assembly in Assemblies) { writer.WriteStartElement("assembly"); writer.WriteStartAttribute("ref"); writer.WriteString(assembly); writer.WriteEndAttribute(); writer.WriteEndElement(); } writer.WriteEndElement(); } if (Dependencies != null) { writer.WriteStartElement("dependencies"); foreach (var dependency in Dependencies) { writer.WriteStartElement("dependency"); writer.WriteStartAttribute("ref"); writer.WriteString(dependency); writer.WriteEndAttribute(); writer.WriteEndElement(); } writer.WriteEndElement(); } }
protected override void WriteElementProperties(System.Xml.XmlWriter writer, object obj, ITypeSerializationInfo info, XmlSerializationContext context) { if (info.DefaultProperty != null) { var content = info.DefaultProperty.GetValue(obj, context); if (info.DefaultProperty.ShouldSerializeValue(obj, content)) { writer.WriteString(GetAttributeValue(content, info.DefaultProperty.PropertyType, false, context)); } } foreach (XmlPropertySerializationInfo pi in info.ElementProperties) { var value = pi.GetValue(obj, context); if (pi.ShouldSerializeValue(obj, value)) { if (pi.PropertyType.IsCollection) { var collectionType = pi.PropertyType.CollectionItemType.Type; foreach (object item in value as IEnumerable) { writer.WriteStartElement(pi.NamespacePrefix, pi.ElementName, pi.Namespace); var itemType = item.GetType(); var itemInfo = GetSerializationInfo(itemType, true); if (itemType != collectionType) { WriteTypeQualifier(writer, itemInfo); } if (itemInfo.IsStringConvertible) { writer.WriteString(itemInfo.ConvertToString(item)); } else { Serialize(item, writer, pi, false, pi.IdentificationMode, context); } writer.WriteEndElement(); } } else { writer.WriteStartElement(pi.NamespacePrefix, pi.ElementName, pi.Namespace); if (value != null) { var type = value.GetType(); if (type != pi.PropertyType.Type.GetImplementationType()) { WriteTypeQualifier(writer, GetSerializationInfo(type, true)); } } else { throw new NotImplementedException(); } Serialize(value, writer, pi, false, pi.IdentificationMode, context); writer.WriteEndElement(); } } } }
protected override void WriteXmlData(XmlWriter writer) { var data = (WhoAndWhenData)GetData(); writer.WriteStartElement("Who"); writer.WriteString(data.Who == null ? string.Empty : data.Who.Path); writer.WriteEndElement(); writer.WriteStartElement("When"); writer.WriteString(XmlConvert.ToString(data.When, XmlDateTimeSerializationMode.Unspecified)); writer.WriteEndElement(); }
internal override void WriteTo(XmlWriter writer) { base.WriteTo(writer); writer.WriteStartElement("MessageNumber"); writer.WriteString(this.sequenceNumber.ToString(CultureInfo.InvariantCulture)); writer.WriteEndElement(); writer.WriteStartElement("LastMessage"); writer.WriteString(this.isLast.ToString(CultureInfo.InvariantCulture)); writer.WriteEndElement(); }
public override void writeToXml(XmlWriter xmlWriter) { xmlWriter.WriteStartElement(CENTER); xmlWriter.WriteString(center.X + "," + center.Y + "," + center.Z); xmlWriter.WriteEndElement(); xmlWriter.WriteStartElement(QUATERNIONS); xmlWriter.WriteString(quaternion.W + "," + quaternion.X + "," + quaternion.Y + "," + quaternion.Z); xmlWriter.WriteEndElement(); }
public override bool ExportAsXml(XmlWriter writer) { writer.WriteStartElement("name"); writer.WriteString(Name); writer.WriteEndElement(); writer.WriteStartElement("data"); writer.WriteString(Data); writer.WriteEndElement(); return true; }
protected override void InnerSerialize(System.Xml.XmlWriter writer) { if (_dataValue) { writer.WriteString("B"); } else { writer.WriteString("A"); } }
private void WriteSpellXml(XmlWriter w, string name, SpellDescription spell) { string shortName = Regex.Replace(name, "[^\\w]", "").ToLower(); w.WriteStartElement(shortName); w.WriteStartElement("name"); w.WriteAttributeString("type", "string"); w.WriteString(name); w.WriteEndElement(); // name w.WriteStartElement("school"); w.WriteAttributeString("type", "string"); w.WriteString(spell.School); w.WriteEndElement(); // school w.WriteStartElement("level"); w.WriteAttributeString("type", "string"); w.WriteString(spell.Level); w.WriteEndElement(); // level w.WriteStartElement("components"); w.WriteAttributeString("type", "string"); w.WriteString(spell.Components); w.WriteEndElement(); // components w.WriteStartElement("castingtime"); w.WriteAttributeString("type", "string"); w.WriteString(spell.CastingTime); w.WriteEndElement(); // castingtime w.WriteStartElement("range"); w.WriteAttributeString("type", "string"); w.WriteString(spell.Range); w.WriteEndElement(); // range w.WriteStartElement("effect"); w.WriteAttributeString("type", "string"); w.WriteString(spell.Effect); w.WriteEndElement(); // effect w.WriteStartElement("duration"); w.WriteAttributeString("type", "string"); w.WriteString(spell.Duration); w.WriteEndElement(); // duration w.WriteStartElement("save"); w.WriteAttributeString("type", "string"); w.WriteString(spell.Save); w.WriteEndElement(); // save w.WriteStartElement("sr"); w.WriteAttributeString("type", "string"); w.WriteString(spell.AllowSpellResistance ? "Yes" : "No"); w.WriteEndElement(); // sr w.WriteStartElement("description"); w.WriteAttributeString("type", "formattedtext"); var description = Regex.Replace(spell.LongDescription, @"[\r\n]+", ""); // replace HTML tags with their lowercase versions (formattedtext is case sensitive...) // we don't support very many; h1, p, b, i, u, table, tr, td description = Regex.Replace(description, @"<[^<>]+>", m => { return m.Value.ToLower(); }); w.WriteRaw(description); w.WriteEndElement(); // description w.WriteStartElement("shortdescription"); w.WriteAttributeString("type", "string"); w.WriteString(spell.ShortDescription); w.WriteEndElement(); // shortdescription w.WriteEndElement(); // <shortName> }
private static void WriteKeyValue(XmlWriter writer, string key, object value) { if (value.GetType() == typeof(string)) { writer.WriteStartElement("String"); if (key != null) writer.WriteAttributeString("Key", key); writer.WriteString((string)value); writer.WriteEndElement(); } else if (value.GetType() == typeof(bool)) { writer.WriteStartElement("Boolean"); if (key != null) writer.WriteAttributeString("Key", key); writer.WriteString(value.ToString()); writer.WriteEndElement(); } else if (value.GetType() == typeof(DateTime)) { writer.WriteStartElement("DateTime"); if (key != null) writer.WriteAttributeString("Key", key); writer.WriteString(((DateTime)value).ToString("G")); writer.WriteEndElement(); } else if (value.GetType() == typeof(TimeSpan)) { writer.WriteStartElement("TimeSpan"); if (key != null) writer.WriteAttributeString("Key", key); writer.WriteString(((TimeSpan)value).ToString("G")); writer.WriteEndElement(); } else if (value.GetType() == typeof(int)) { writer.WriteStartElement("Int32"); if (key != null) writer.WriteAttributeString("Key", key); writer.WriteString(((int)value).ToString()); writer.WriteEndElement(); } else if (value.GetType() == typeof(List<object>)) { WriteArray(writer, key, (List<object>)value); } else if (value.GetType() == typeof(Dictionary<string, object>)) { WriteDict(writer, key, (Dictionary<string, object>)value); } }
/// <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)); } } } }
public void WriteXml(System.Xml.XmlWriter writer) { foreach (String key in this.Keys) { writer.WriteStartElement("Property"); writer.WriteAttributeString("Name", this[key].name); if (this[key].type == typeof(string)) { writer.WriteAttributeString("Type", "string"); } if (this[key].type == typeof(bool)) { writer.WriteAttributeString("Type", "bool"); } if (this[key].type == typeof(Vector2)) { writer.WriteAttributeString("Type", "Vector2"); } if (this[key].type == typeof(Color)) { writer.WriteAttributeString("Type", "Color"); } if (this[key].type == typeof(Component)) { writer.WriteAttributeString("Type", "Item"); } writer.WriteAttributeString("Description", this[key].description); if (this[key].type == typeof(Component)) { Component item = (Component)this[key].value; if (item != null) { writer.WriteString(item.Name); } else { writer.WriteString("$null$"); } } else { XmlSerializer valueSerializer = new XmlSerializer(this[key].type); valueSerializer.Serialize(writer, this[key].value); } writer.WriteEndElement(); } }
public void SaveXml(CompilationUnit cu) { try { this.cu = cu; is_assembly = cu.SyntaxTree is SyntaxTree.program_module || Compiler.is_dll(cu.SyntaxTree); XmlWriterSettings settings = new XmlWriterSettings(); settings.Encoding = Encoding.UTF8; settings.Indent = true; xtw = XmlTextWriter.Create(Path.ChangeExtension(cu.UnitName, ".xml"), settings); unit_name = Path.GetFileNameWithoutExtension(cu.UnitName); xtw.WriteStartDocument(); xtw.WriteStartElement("doc"); if (is_assembly) { xtw.WriteStartElement("assembly"); xtw.WriteStartElement("name"); xtw.WriteString(Path.GetFileNameWithoutExtension(cu.UnitName)); xtw.WriteEndElement(); xtw.WriteEndElement(); } else { xtw.WriteStartElement("unit"); xtw.WriteStartAttribute("name"); //xtw.WriteString((cu.SemanticTree as common_unit_node).unit_name); xtw.WriteString(Path.GetFileNameWithoutExtension(cu.UnitName)); xtw.WriteEndAttribute(); xtw.WriteString(cu.SemanticTree.documentation); xtw.WriteEndElement(); } SaveMembers(); xtw.WriteEndElement(); xtw.Flush(); } catch (Exception e) { } try { if (xtw != null) xtw.Close(); } catch { } }
/// <summary> /// Write as text /// </summary> internal override void WriteText(System.Xml.XmlWriter w) { if (this.Value.Scheme == "http" || this.Value.Scheme == "https") { w.WriteStartElement("a", NS_XHTML); w.WriteAttributeString("href", this.Value.ToString()); w.WriteString(this.Value.ToString()); w.WriteEndElement(); // a } else { w.WriteString(this.Value.ToString()); } }
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(); }
public void WriteXml(System.Xml.XmlWriter writer) { XmlSerializer keySerializer = new XmlSerializer(typeof(string)); XmlSerializer valueSerializer = new XmlSerializer(typeof(T)); foreach (string key in this.Keys) { writer.WriteStartElement("item"); writer.WriteAttributeString("key", key); if (this[key] is string) { writer.WriteString(this[key].ToString()); } else { XmlSerializer xmlSerializer = new XmlSerializer(typeof(T)); using (StringWriter textWriter = new StringWriter()) { xmlSerializer.Serialize(textWriter, this[key]); XmlDocument doc = new XmlDocument(); doc.LoadXml(textWriter.ToString()); writer.WriteRaw(doc.GetElementsByTagName(typeof(T).Name)[0].InnerXml); } } writer.WriteEndElement(); } }
public static void ProcessDirectory(string targetDirectory, XmlWriter writer) { // Process the list of files found in the directory. string[] fileEntries = Directory.GetFiles(targetDirectory); writer.WriteStartElement("dir"); foreach (string fileName in fileEntries) { writer.WriteStartElement("file"); writer.WriteString(fileName); writer.WriteEndElement(); } // Recurse into subDirectories of this directory. string[] subDirectoryEntries = Directory.GetDirectories(targetDirectory); foreach (string subDirectory in subDirectoryEntries) { writer.WriteStartElement("dir"); writer.WriteAttributeString("dirName", subDirectory); ProcessDirectory(subDirectory, writer); writer.WriteEndElement(); } writer.WriteEndElement(); }
/// <summary> /// Converts the given value to the ATOM string representation /// and uses the writer to write it. /// </summary> /// <param name="writer">The writer to write the stringified value.</param> /// <param name="value">The value to be written.</param> /// <param name="expectedType">The expected resource type of the value or null if no metadata is available.</param> internal static void WritePrimitiveValue(XmlWriter writer, object value, ResourceType expectedType) { DebugUtils.CheckNoExternalCallers(); Debug.Assert(value != null, "value != null"); string result; bool preserveWhitespace; if (!TryConvertPrimitiveToString(value, out result, out preserveWhitespace)) { throw new ODataException(Strings.AtomValueUtils_CannotConvertValueToAtomPrimitive(value.GetType().FullName)); } if (expectedType != null) { ValidationUtils.ValidateIsExpectedPrimitiveType(value, expectedType); } if (preserveWhitespace) { writer.WriteAttributeString( AtomConstants.XmlNamespacePrefix, AtomConstants.XmlSpaceAttributeName, AtomConstants.XmlNamespace, AtomConstants.XmlPreserveSpaceAttributeValue); } writer.WriteString(result); }
protected override void WriteValue(XmlWriter writer, object value) { IDictionary dictionary = (IDictionary) value; foreach (object key in dictionary.Keys) { object target = dictionary[key]; // any way to refactor code block? ReflectorTypeAttribute typeAttribute = ReflectorTypeAttribute.GetAttribute(target); if (typeAttribute == null) { writer.WriteStartElement(elementName); writer.WriteAttributeString(attribute.Key, key.ToString()); writer.WriteString(target.ToString()); writer.WriteEndElement(); } else { writer.WriteStartElement(typeAttribute.Name); writer.WriteAttributeString(attribute.Key, key.ToString()); XmlTypeSerialiser serialiser = (XmlTypeSerialiser) typeAttribute.CreateSerialiser(target.GetType()); serialiser.WriteMembers(writer, target); writer.WriteEndElement(); } } }
public void WriteXml(System.Xml.XmlWriter writer) { Array.ForEach( Fields, delegate(EntityDbField item) { writer.WriteStartElement(XmlConvert.EncodeLocalName(item.DbName)); writer.WriteAttributeString("length", item.DbLength.ToString()); writer.WriteAttributeString("dbType", item.DbType.ToString()); object val = GetValueForDbField(item); if (null != val) { try { writer.WriteValue(GetValueForDbField(item)); } catch { writer.WriteString( typeof(XmlConvert).InvokeMember( "ToString", BindingFlags.Static | BindingFlags.Public | BindingFlags.InvokeMethod, null, null, new Object[] { GetValueForDbField(item) }).ToString()); } } writer.WriteEndElement(); }); }
public static void WriteMapping(XmlWriter writer, ISymbolMapping mapping) { writer.WriteStartElement(mapping.GetType().Name); writer.WriteAttributeString("Name", mapping.Name); var replaceMapping = mapping as ReplaceMapping; if (replaceMapping != null) { foreach (var replacement in replaceMapping.Replacements.OrderBy(kv => kv.Key)) { writer.WriteStartElement("Replacement"); writer.WriteAttributeString("Replace", replacement.Key); writer.WriteAttributeString("With", replacement.Value); writer.WriteEndElement(); } var scriptedMapping = replaceMapping as ScriptedMapping; if (scriptedMapping != null) { writer.WriteStartElement("ScriptBody"); writer.WriteString(scriptedMapping.ScriptBody); writer.WriteEndElement(); } } writer.WriteEndElement(); }
// Originally this class used the XML attributes to serialize itself // via an XmlSerializer, but that turns out not the work (see the comments // in EventWriter). So instead we have localized all the XML related code // in this one method. It turns out to be simpler to understand, too. public void ToXml(XmlWriter writer) { Contract.Requires(writer != null); writer.WriteStartElement("event"); if (Stanza != null) writer.WriteAttributeString("stanza", Stanza); if (Unbroken) writer.WriteAttributeString("unbroken", "1"); if (Data != null) WriteTextElement(writer, "data", Data); if (Source != null) WriteTextElement(writer, "source", Source); if (SourceType != null) WriteTextElement(writer, "sourcetype", SourceType); if (Index != null) WriteTextElement(writer, "index", Index); if (Host != null) WriteTextElement(writer, "host", Host); if (Time.HasValue) { double timestamp = (double)(Time.Value.Ticks - ticksSinceEpoch) / TimeSpan.TicksPerSecond; writer.WriteStartElement("time"); writer.WriteString(timestamp.ToString()); writer.WriteEndElement(); } if (Done) { writer.WriteStartElement("done"); writer.WriteEndElement(); } writer.WriteEndElement(); }
internal static void WriteElement(XmlWriter writer, XElement element) { if (WriteWholeNode(element)) { // Write entire element in one gulp, to avoid eating needed spaces in <Run> elements. element.WriteTo(writer); } else { writer.WriteStartElement(element.Name.LocalName); foreach (var attribute in element.Attributes()) { writer.WriteAttributeString(attribute.Name.LocalName, attribute.Value); } if (element.HasElements) { foreach (var childNode in element.Elements().ToArray()) { // Recurse on down to the bottom. WriteElement(writer, childNode); childNode.Remove(); } } else { if (!string.IsNullOrEmpty(element.Value)) writer.WriteString(element.Value); } writer.WriteEndElement(); } }
private void WriteIntFlags2Content(XmlTextWriter writer, MetaInt32_Enum3 intValue) { if (intValue.Value != 0) { StringBuilder sb = new StringBuilder(); for (int i = 0; i < 32; i++) { if ((intValue.Value & (1 << i)) != 0) { if (intValue.info != null) { foreach (var xy in intValue.info.Entries) { if (xy.EntryValue == i) { sb.Append(" "); sb.Append(GetFlagNameForHash(xy.EntryNameHash)); } } } else { sb.Append(" flag_index_"); sb.Append(i.ToString()); } } } writer.WriteString(sb.ToString().Trim()); } }
public static void WriteLdmlText(XmlWriter writer, string text) { // Not all Unicode characters are valid in an XML document, so we need to create // the <cp hex="X"> elements to replace the invalid characters. // Note: While 0xD (carriage return) is a valid XML character, it is automatically // either dropped or coverted to 0xA by any conforming XML parser, so we also make a <cp> // element for that one. StringBuilder sb = new StringBuilder(text.Length); for (int i=0; i < text.Length; i++) { int code = Char.ConvertToUtf32(text, i); if ((code == 0x9) || (code == 0xA) || (code >= 0x20 && code <= 0xD7FF) || (code >= 0xE000 && code <= 0xFFFD) || (code >= 0x10000 && code <= 0x10FFFF)) { sb.Append(Char.ConvertFromUtf32(code)); } else { writer.WriteString(sb.ToString()); writer.WriteStartElement("cp"); writer.WriteAttributeString("hex", String.Format("{0:X}", code)); writer.WriteEndElement(); sb = new StringBuilder(text.Length - i); } if (Char.IsSurrogatePair(text, i)) { i++; } } writer.WriteString(sb.ToString()); }
void IXmlSerializable.WriteXml(XmlWriter writer) { if (writer == null) { throw new ArgumentNullException(nameof(writer)); } writer.WriteAttributeString("IsPinned", IsPinned.ToString()); writer.WriteString(Path); }
public void WriteXml(XmlWriter writer) { if (writer == null) { throw new ArgumentException("writer"); } writer.WriteAttributeString("IsPinned", isPinned.ToString()); writer.WriteString(path); }
private void createElement(XmlWriter writer, string whitespace, string name, string value) { writer.WriteWhitespace(whitespace); writer.WriteStartElement(name); writer.WriteString(value); writer.WriteEndElement(); }
private static void WriteShapes(XmlWriter writer, GraphAbstract g) { writer.WriteStartElement("g"); for(int k=0; k<g.Shapes.Count; k++) //<rect x="1140" y="30" width="100" height="20" style="fill: url(#two_hues); stroke: black;"/> { writer.WriteStartElement("rect"); writer.WriteAttributeString("x", g.Shapes[k].X.ToString()); writer.WriteAttributeString("y", g.Shapes[k].Y.ToString()); writer.WriteAttributeString("width", g.Shapes[k].Width.ToString()); writer.WriteAttributeString("height", g.Shapes[k].Height.ToString()); writer.WriteAttributeString("rx", "2");//rounded rectangle //writer.WriteAttributeString("style", "fill: url(#two_hues); stroke: black;"); writer.WriteAttributeString("fill", string.Concat("#", (g.Shapes[k].ShapeColor.ToArgb() & 0x00FFFFFF).ToString("X6")) ); writer.WriteEndElement(); //<text text-anchor="middle" x="{$x+50}" y="{$y+15}"> writer.WriteStartElement("text"); writer.WriteAttributeString("x", Convert.ToString(g.Shapes[k].X + 10)); writer.WriteAttributeString("y", Convert.ToString(g.Shapes[k].Y + 15)); writer.WriteAttributeString("text-anchor", "start"); writer.WriteAttributeString("font-size", "9"); writer.WriteString(g.Shapes[k].Text); writer.WriteEndElement(); } writer.WriteEndElement(); }
internal override void WriteTo(XmlWriter writer) { base.WriteTo(writer); writer.WriteStartElement("Identifier"); writer.WriteString(this.id.ToString()); writer.WriteEndElement(); }
/// <summary> /// Saving the object into an xml node /// </summary> /// <param name="comp">this compiler</param> /// <param name="writer">Xml writer object</param> /// <param name="child">html child for nested objects</param> public void Save(ICompilateur comp, System.Xml.XmlWriter writer, ref System.Windows.Forms.HtmlElement child) { writer.WriteStartElement("createmop"); writer.WriteAttributeString("language", this.language); writer.WriteAttributeString("name", this.name); if (this.indent > 0) { writer.WriteAttributeString("indent", this.indent.ToString()); } writer.WriteStartElement("legendes"); this.legendes.Save(writer); writer.WriteEndElement(); writer.WriteStartElement("references"); foreach (string param in this.refs) { writer.WriteStartElement("ref"); writer.WriteString(param); writer.WriteEndElement(); } writer.WriteEndElement(); writer.WriteStartElement("code"); writer.WriteRaw(this.xmlCode); writer.WriteEndElement(); writer.WriteEndElement(); child = child.NextSibling; }
/// <summary> /// Creates XML elements from the data of the system. /// </summary> /// <param name="xmlWriter">Object with the XML message to add new information and return to client side</param> /// <param name="val">Value to be puted inside the XML message</param> /// <param name="dtdVersion">Version of the DTD that follows the XML message</param> /// <param name="xmlElement">Element of the XML that is checked</param> public static void ON2XML(XmlWriter xmlWriter, ONReal val, double dtdVersion, string xmlElement) { if (val == null) { if (xmlElement == ONXml.XMLTAG_V) xmlWriter.WriteElementString(xmlElement, ""); else xmlWriter.WriteElementString(ONXml.XMLTAG_NULL, null); } else { if (dtdVersion < 2.0) // Apply the locale format xmlWriter.WriteElementString(xmlElement, val.TypedValue.ToString("0.##############")); else { xmlWriter.WriteStartElement(xmlElement); if (xmlElement == ONXml.XMLTAG_OIDFIELD && dtdVersion > 2.0) xmlWriter.WriteAttributeString("Type", "real"); string lValue = Pack(val); xmlWriter.WriteString(lValue); xmlWriter.WriteEndElement(); } } }
public static void WriteXmlLogStart(XmlWriter xw) { xw.WriteStartDocument(); xw.WriteStartElement("LogEntries"); xw.WriteString("\r\n"); xw.WriteComment(StaticVariables.Logo(false) + "\r\n" + CurrentQuery + "\r\n"); //+ CurrentEntryCount + "\r\n"); }
private void WriteStringContent(XmlTextWriter writer, PsoString3 value) { if (value.Value != null) { writer.WriteString(value.Value.Replace("\0", "")); } }
public void WriteXml(XmlWriter xw) { xw.WriteStartElement(VerificationMessage._xml_tag); xw.WriteAttributeString(VerificationMessage._xml_message_sourcefile_attr, this.sourceLabel); xw.WriteString(this.message); xw.WriteEndElement(); }
private void WriteStringContent(XmlTextWriter writer, PsoString8 value) { if (value.Value != 0) { writer.WriteString(GetNameForHash(value.Value)); } }
private static void WriteReportFieldsXml(XmlWriter writer, Report report) { writer.WriteStartElement("Fields"); foreach (var field in report.Fields.Where(field => field.FieldType != FieldType.SectionRepeater)) { writer.WriteStartElement("Field-" + field.FieldType); writer.WriteAttributeString("Label", field.Label); if (field.FieldType != FieldType.CheckList && field.FieldType != FieldType.Location) { writer.WriteString(field.Value); } else { foreach (var item in field.ChildItems) { writer.WriteElementString(item.Item, item.Value); } } writer.WriteEndElement(); } writer.WriteEndElement(); }
public new void WriteXml(System.Xml.XmlWriter writer) { base.WriteXml(writer); writer.WriteElementString("PollType", PollType.ToString("D")); writer.WriteElementString("ShowAnswerCount", ShowAnswerCount.ToString("D")); writer.WriteElementString("ShowResult", ShowResult.ToString("D")); writer.WriteElementString("PollLayout", PollLayout.ToString("D")); writer.WriteElementString("AnonymousAllowed", AnonymousAllowed.ToString()); writer.WriteElementString("HasAnswers", HasAnswers.ToString()); writer.WriteElementString("AnswerAnonnymous", AnswerAnonnymous.ToString()); writer.WriteElementString("AnswerRegisterd", AnswerRegisterd.ToString()); writer.WriteElementString("AnswerTotal", AnswerTotal.ToString()); writer.WriteElementString("TextRight", TextRight); writer.WriteElementString("TextFalse", TextFalse); writer.WriteElementString("TextPartially", TextPartially); writer.WriteStartElement("Answers"); foreach (PollAnswer kvp in Answers) { writer.WriteStartElement("Answer"); writer.WriteAttributeString("Position", kvp.Position.ToString()); writer.WriteAttributeString("Anonnymous", kvp.Anonnymous.ToString()); writer.WriteAttributeString("Registerd", kvp.Registerd.ToString()); writer.WriteAttributeString("IsRight", kvp.IsRight.ToString()); writer.WriteString(kvp.Answer); writer.WriteEndElement(); } writer.WriteEndElement(); }
private void WriteFlagsContent(XmlTextWriter writer, PsoFlagsInt value) { var sb = new StringBuilder(); for (int i = 0; i < 32; i++) { if ((value.Value & (1 << i)) != 0) { var machingFlagEntry = (PsoEnumEntryInfo)null; foreach (var flagEntry in value.TypeInfo.Entries) { if (flagEntry.EntryKey == i) { machingFlagEntry = flagEntry; } } var matchingFlagName = GetNameForHash(machingFlagEntry.EntryNameHash); sb.Append(matchingFlagName + " "); } } var flagsString = sb.ToString().Trim(); writer.WriteString(flagsString); }
public void Render(System.Xml.XmlWriter writer) { writer.WriteStartDocument(true); writer.WriteStartElement("", "Customer", "mvp-xml-templates"); writer.WriteAttributeString("", "xmlns", "http://www.w3.org/2000/xmlns/", "mvp-xml-templates"); writer.WriteAttributeString("", "Name", "", Converter.ToString(customer.LastName + ", " + customer.FirstName)); writer.WriteStartElement("", "Orders", "mvp-xml-templates"); foreach (Order o in customer.Orders) //; { writer.WriteStartElement("", "Order", "mvp-xml-templates"); writer.WriteAttributeString("", "Id", "", Converter.ToString(o.Id)); writer.WriteAttributeString("", "Premium", "", Converter.ToString((o.GrandTotal > 10000))); writer.WriteStartElement("", "Items", "mvp-xml-templates"); writer.WriteAttributeString("", "GrandTotal", "", Converter.ToString(CalculateTotals(o))); foreach (Item i in o.Items) //; { writer.WriteStartElement("", "Item", "mvp-xml-templates"); writer.WriteAttributeString("", "Id", "", Converter.ToString(i.ProductId)); writer.WriteAttributeString("", "SubTotal", "", Converter.ToString(i.Quantity * i.Price)); writer.WriteEndElement(); }//; writer.WriteEndElement(); writer.WriteStartElement("", "Recipe", "http://schemas.microsoft.com/pag/gax-core"); writer.WriteAttributeString("", "xmlns", "http://www.w3.org/2000/xmlns/", "http://schemas.microsoft.com/pag/gax-core"); writer.WriteAttributeString("", "Name", "", "Foo"); writer.WriteStartElement("", "Caption", "http://schemas.microsoft.com/pag/gax-core"); writer.WriteString(Converter.ToString(o.DateOrdered)); writer.WriteEndElement(); writer.WriteStartElement("", "Description", "http://schemas.microsoft.com/pag/gax-core"); writer.WriteString(("\n\t\t\t\t\tExample of escaping the curly braces: \n\t\t\t\t\tstring.Format(\"" + (Converter.ToString({ 0 })
private static void WriteElementTo(PmlElement Element, System.Xml.XmlWriter Writer) { switch (Element.Type) { case PmlType.Binary: Writer.WriteAttributeString("type", "binary"); byte[] Bytes = Element.ToByteArray(); Writer.WriteBase64(Bytes, 0, Bytes.Length); break; case PmlType.Collection: Writer.WriteAttributeString("type", "collection"); foreach (PmlElement Child in (PmlCollection)Element) { Writer.WriteStartElement("item"); WriteElementTo(Child, Writer); Writer.WriteEndElement(); } break; case PmlType.Dictionary: Writer.WriteAttributeString("type", "dictionary"); foreach (KeyValuePair <string, PmlElement> Child in (PmlDictionary)Element) { Writer.WriteStartElement(Child.Key); WriteElementTo(Child.Value, Writer); Writer.WriteEndElement(); } break; case PmlType.Integer: Writer.WriteAttributeString("type", "integer"); Writer.WriteString(Element.ToString()); break; case PmlType.Null: Writer.WriteAttributeString("type", "null"); break; case PmlType.String: Writer.WriteAttributeString("type", "string"); Writer.WriteString(Element.ToString()); break; } }
static private void WriteProperty(object record, PropertyInfo property, System.Xml.XmlWriter write) { write.WriteStartElement("param"); write.WriteAttributeString("name", property.Name); string parameterType = PdkXmlSerializer.MapType(property.GetGetMethod().ReturnType); write.WriteAttributeString("type", parameterType); object val = property.GetValue(record, null); if (val != null) { if (parameterType == "record") { WriteRecord(val, write); } else if (parameterType == "sequence") { if (property.PropertyType == typeof(string[])) { write.WriteAttributeString(PdkXmlSerializer.SequenceTypeAttributename, PdkXmlSerializer.MapType(typeof(string))); Array ar = (Array)val; for (int i = 0; i < ar.Length; ++i) { write.WriteStartElement(PdkXmlSerializer.ItemElementname); write.WriteString(ar.GetValue(i).ToString()); write.WriteEndElement(); } } else { write.WriteAttributeString(PdkXmlSerializer.SequenceTypeAttributename, PdkXmlSerializer.RecordElementname); Array ar = (Array)val; for (int i = 0; i < ar.Length; ++i) { write.WriteStartElement(PdkXmlSerializer.ItemElementname); WriteRecord(ar.GetValue(i), write); } } } else { write.WriteString(PdkXmlSerializer.SerializeValue(val)); } } write.WriteEndElement(); }
public virtual void WriteXml(System.Xml.XmlWriter writer) { writer.WriteStartElement("NestedWriteString"); writer.WriteStartElement("container2"); writer.WriteString("container2 content"); writer.WriteEndElement(); //container2 writer.WriteEndElement(); //NestedWriteString }
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(); }
private void WriteIntEnumContent(XmlTextWriter writer, MetaInt32_Enum1 intValue) { if (intValue.Value != -1) { var thehash = (int)0; foreach (var enty in intValue.info.Entries) { if (enty.EntryValue == intValue.Value) { thehash = enty.EntryNameHash; } } writer.WriteString(GetEnumNameForHash(thehash)); } else { writer.WriteString("enum_NONE"); } }
public void WriteXml(System.Xml.XmlWriter writer) { foreach (string key in this.Keys) { writer.WriteStartElement(key); string value = this[key]; writer.WriteString(value); writer.WriteEndElement(); } }
private void ExportDataId(System.Xml.XmlWriter writer) { var data = GetData(); var node = data as Node; if (node != null) { writer.WriteString(node.Id.ToString()); return; } var nodeList = data as NodeList <Node>; if (nodeList != null) { writer.WriteString(String.Join(",", nodeList.GetIdentifiers())); return; } var nodeEnumerable = data as IEnumerable <Node>; if (nodeEnumerable != null) { writer.WriteString(String.Join(",", nodeEnumerable.Select(n => n.Id))); return; } var nodes = data as IEnumerable; if (nodes != null) { var ids = new List <int>(); foreach (Node n in nodes) { ids.Add(n.Id); } writer.WriteString(String.Join(",", ids)); return; } throw ExportNotSupportedException(GetData()); }
public void WriteXml(System.Xml.XmlWriter writer) { foreach (var key in this.Keys) { writer.WriteStartElement("item"); writer.WriteAttributeString("key", key); string value = this[key]; writer.WriteString(value); writer.WriteEndElement(); } }
/// <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 static void WriteX(this System.Xml.XmlWriter x, Label label) { var t = label.Text; x.WriteStartElement("Paragraph"); x.WriteTextStyleAttributes(label.TextStyle); if (t != null) { x.WriteString(t); } x.WriteEndParagraph(); }
public static void WriteRunValue(this System.Xml.XmlWriter x, string t) { x.WriteStartRun(); if (t != null) { if (t.Length > 0) { x.WriteString(t); } } x.WriteEndRun(); }