static void MergeCData(XCData dst, XCData src) { if (dst.Value != src.Value) { dst.Value = src.Value; } }
private static string SerializeToXml(TransportMessage transportMessage) { var overrides = new XmlAttributeOverrides(); var attrs = new XmlAttributes { XmlIgnore = true }; // Exclude non-serializable members overrides.Add(typeof(TransportMessage), "Body", attrs); overrides.Add(typeof(TransportMessage), "ReplyToAddress", attrs); overrides.Add(typeof(TransportMessage), "Headers", attrs); var sb = new StringBuilder(); var xws = new XmlWriterSettings { Encoding = Encoding.Unicode }; var xw = XmlWriter.Create(sb, xws); var xs = new XmlSerializer(typeof(TransportMessage), overrides); xs.Serialize(xw, transportMessage); var xdoc = XDocument.Parse(sb.ToString()); var body = new XElement("Body"); var cdata = new XCData(Encoding.UTF8.GetString(transportMessage.Body)); body.Add(cdata); xdoc.SafeElement("TransportMessage").Add(body); sb.Clear(); var sw = new StringWriter(sb); xdoc.Save(sw); return(sb.ToString()); }
public void XCDataChangeValue() { XCData toChange = new XCData("Original Value"); String newValue = "New Value"; XElement xElem = new XElement("root", toChange); XElement xElemOriginal = new XElement(xElem); using (UndoManager undo = new UndoManager(xElem)) { undo.Group(); using (EventsHelper eHelper = new EventsHelper(xElem)) { using (EventsHelper dataHelper = new EventsHelper(toChange)) { toChange.Value = newValue; Assert.True(toChange.Value.Equals(newValue), "Value did not change"); xElem.Verify(); dataHelper.Verify(XObjectChange.Value, toChange); } eHelper.Verify(XObjectChange.Value, toChange); } undo.Undo(); Assert.True(XNode.DeepEquals(xElem, xElemOriginal), "Undo did not work!"); } }
/// <summary> /// Tests the WriteTo method on XTest. /// </summary> /// <param name="contextValue"></param> /// <returns></returns> //[Variation(Desc = "TextWriteTo")] public void TextWriteTo() { XCData c = new XCData("abcd"); // Null writer not allowed. try { c.WriteTo(null); Validate.ExpectedThrow(typeof(ArgumentNullException)); } catch (Exception ex) { Validate.Catch(ex, typeof(ArgumentNullException)); } // Test. StringBuilder stringBuilder = new StringBuilder(); XmlWriter xmlWriter = XmlWriter.Create(stringBuilder); xmlWriter.WriteStartElement("x"); c.WriteTo(xmlWriter); xmlWriter.WriteEndElement(); xmlWriter.Flush(); Validate.IsEqual( stringBuilder.ToString(), "<?xml version=\"1.0\" encoding=\"utf-16\"?><x><![CDATA[abcd]]></x>"); }
/// <summary> /// create node for every addin /// store data of addin in xml /// </summary> /// <param name="xeAddins"></param> private void GetAddinXml(XElement xeAddins) { XElement xeAddin = null; XCData xeCdata = null; try { if (m_lstAddins != null && m_lstAddins.Count > 0) { foreach (IWAddIn objAddin in m_lstAddins) { xeAddin = new XElement("addin"); xeAddin.SetAttributeValue("addinid", objAddin.InstanceId); xeAddin.SetAttributeValue("name", objAddin.Name); xeAddin.SetAttributeValue("type", objAddin.AddinType); if (!string.IsNullOrEmpty(objAddin.Config)) { xeCdata = new XCData(objAddin.Config); if (xeCdata != null) { xeAddin.Add(xeCdata); } } xeAddins.Add(xeAddin); } } } finally { xeAddin = null; xeCdata = null; } }
public void SaveCurrentSyllableState(List <string[]> data, int index) { var xmlCurrentState = Settings.xmlConfig.Element("current-state"); if (xmlCurrentState == null) { xmlCurrentState = new XElement("current-state"); xmlConfig.Add(xmlCurrentState); } var xIndex = new XAttribute("index", index); StringBuilder sb = new StringBuilder(); foreach (var syllables in data) { sb.Append(string.Join(",", syllables)).Append("|"); } sb.Length--; var xData = new XCData(sb.ToString()); xmlCurrentState.Element("syllables")?.Remove(); var xmlSyllables = new XElement("syllables", xIndex, xData); xmlCurrentState.Add(xmlSyllables); SaveXmlConfig(); }
private static string XPathResultGetValue(object xpathResult, bool acceptCData = false) { if (xpathResult is string) { return(xpathResult as string); } else if (xpathResult is XAttribute) { return((xpathResult as XAttribute).Value); } // modif le 09/02/2015 else if (xpathResult is XText) { return((xpathResult as XText).Value); } else if (xpathResult is XElement) { //value = (xpathResult as XElement).zTextOrAttribValue(); XElement xe = (XElement)xpathResult; XAttribute attrib = xe.Attribute("value"); if (attrib != null) { return(attrib.Value); } if (acceptCData) { XCData cdata = GetUniqueCDataChild(xe); if (cdata != null) { return(cdata.Value); } } } return(null); }
public XText GetTextEl(XElement el) { XText rt = null; IEnumerable <XNode> lst = el.Nodes(); string value_string = ""; foreach (XNode nd in lst) { if (nd.NodeType == XmlNodeType.Text) { value_string += (string)((XText)nd).Value; } else if (nd.NodeType == XmlNodeType.CDATA) { XCData xcd = (XCData)nd; value_string += xcd.Value; } } rt = new XText(value_string); return(rt); }
public void Save <T>(string path, T t) where T : class, new() { XDocument xdoc = new XDocument(new XDeclaration("1.0", "utf-8", "yes")); XElement root = new XElement("configuration"); PropertyInfo[] pisarr = typeof(T).GetProperties(); foreach (PropertyInfo pi in pisarr) { XElement ele = new XElement(pi.Name); object valObj = pi.GetValue(t, null); if (valObj == null) { valObj = ""; } if (valObj.ToString() != "") { if (pi.PropertyType == typeof(DateTime)) { valObj = DateTime.Parse(valObj.ToString()).ToString("yyyy-MM-dd HH:mm:ss"); } } XCData cdata = new XCData(valObj.ToString()); ele.Add(cdata); root.Add(ele); } if (File.Exists(path)) { File.Delete(path); } root.Save(path, SaveOptions.None); }
private Table WrapWithCitation(XElement image, string caption, XNamespace ns) { var table = new Table(ns); table.AddColumn(0f); // OneNote will set width accordingly var cdata = new XCData(caption); var row = table.AddRow(); var cell = row.Cells.First(); cell.SetContent( new XElement(ns + "OEChildren", new XElement(ns + "OE", new XAttribute("alignment", "center"), image), new XElement(ns + "OE", new XAttribute("alignment", "center"), new XAttribute("quickStyleIndex", citation.Index.ToString()), new XElement(ns + "Meta", new XAttribute("name", "om"), new XAttribute("content", "caption")), new XElement(ns + "T", cdata) ) )); return(table); }
public void TestBuildInput_NoIdentifier_Compression() { ICompressor compressor = new GZipCompressor(); Image img = _createTestImage(); JobInput i = new JobInput(img); i.Compressor = compressor; JobBuilderProcess p = new JobBuilderProcess(); XElement element = p.BuildInput(i); Assert.AreEqual("input", element.Name); Assert.IsNull(element.Attribute("identifier")); Assert.IsNotNull(element.Attribute("compressor")); Assert.AreEqual("gzip", element.Attribute("compressor").Value.ToLower()); XNode child = element.FirstNode; Assert.IsTrue(child.NodeType == System.Xml.XmlNodeType.CDATA); XCData data = (XCData)child; string providedImage = data.Value; string expectedImage = System.Text.Encoding.Default.GetString(CompressionAssistant.Compress(img, compressor)); Assert.AreEqual(expectedImage, providedImage); }
public void TestBuildInput_Identifier_NoCompression() { object identifier = "Test"; Image img = _createTestImage(); JobInput i = new JobInput(img); i.Identifier = identifier; JobBuilderProcess p = new JobBuilderProcess(); XElement element = p.BuildInput(i); Assert.AreEqual("input", element.Name); Assert.IsNotNull(element.Attribute("identifier")); Assert.AreEqual(identifier, element.Attribute("identifier").Value); XNode child = element.FirstNode; Assert.IsTrue(child.NodeType == System.Xml.XmlNodeType.CDATA); XCData data = (XCData)child; string providedImage = data.Value; string expectedImage = System.Text.Encoding.Default.GetString(CompressionAssistant.ImageToBytes(img)); Assert.AreEqual(expectedImage, providedImage); }
/// <summary> /// Constructs Xml using the <see cref="JobInput"/>. /// </summary> /// <param name="input">The <see cref="JobInput"/> to be used as input /// in a job.</param> /// <returns>An <see cref="XElement"/> representing the /// <see cref="JobInput"/>.</returns> /// <exception cref="InvalidOperationException">this /// <see cref="IBuilderProcess"/> does not support building /// inputs.</exception> public XElement BuildInput(JobInput input) { ICollection <object> content = new List <object>(); if (input.Identifier != null) { XAttribute id = new XAttribute("identifier", input.Identifier); content.Add(id); } byte[] imgBytes = null; if (input.Compressor != null) { string compressorId = CompressorFactory.ResolveIdentifier(input.Compressor); imgBytes = CompressionAssistant.Compress(input.Input, input.Compressor); XAttribute compressor = new XAttribute("compressor", compressorId); content.Add(compressor); } else { imgBytes = CompressionAssistant.ImageToBytes(input.Input); } string bytesAsString = System.Text.Encoding.Default.GetString(imgBytes); XCData imgNode = new XCData(bytesAsString); content.Add(imgNode); return(new XElement("input", content)); }
private RpcMethod(string pInterfaceName, string pFunctionName, IEnumerable <object> pParames) { _mElement = new XElement("CallRemoting"); XElement interfaceElement = new XElement("Interface"); interfaceElement.SetValue(pInterfaceName); _mElement.Add(interfaceElement); XElement methodElement = new XElement("Method"); methodElement.SetValue(pFunctionName); _mElement.Add(methodElement); if (pParames != null) { XElement paramsElement = new XElement("Params"); foreach (object param in pParames) { XElement paramElement = new XElement("Param"); paramElement.SetAttributeValue("Type", param.GetType().ToString()); XCData xcd = new XCData(param.ToString()); paramElement.Add(xcd); paramsElement.Add(paramElement); } _mElement.Add(paramsElement); } }
private static XElement CreateNode( string ns, string elementName, XCData value) { return(new XElement($"{ns}:{elementName}", value)); }
private void MakeWordBank(Page page, XNamespace ns, List <string> words) { var sep = page.IsRightToLeft() ? $" {AddIn.Culture.TextInfo.ListSeparator}" : $"{AddIn.Culture.TextInfo.ListSeparator} "; var content = $"<span style='font-weight:bold'>{string.Join(sep, words)}</span>"; var quickIndex = MakeQuickStyle(page); var tagIndex = MakeRibbonTagDef(page, BankType); var outline = page.Root.Elements(ns + "Outline") .FirstOrDefault(e => e.Elements().Any(x => x.Name.LocalName == "Meta" && x.Attribute("name").Value == MetaNames.TaggingBank)); XCData cdata; if (outline == null) { var tag = new XElement(ns + "Tag", new XAttribute("index", tagIndex), new XAttribute("completed", "true"), new XAttribute("disabled", "false")); cdata = new XCData(content); outline = new XElement(ns + "Outline", new XElement(ns + "Position", // 245 accounts for "Wednesday, December 30, 2020 12:12pm" new XAttribute("x", "245"), new XAttribute("y", "43"), new XAttribute("z", "0")), new XElement(ns + "Size", new XAttribute("width", "400"), new XAttribute("height", "11"), new XAttribute("isSetByUser", "true")), new XElement(ns + "Meta", new XAttribute("name", MetaNames.TaggingBank), new XAttribute("content", "1")), new XElement(ns + "OEChildren", new XElement(ns + "OE", new XAttribute("quickStyleIndex", quickIndex), tag, new XElement(ns + "T", cdata) )) ); page.Root.Elements(ns + "Title").First().AddAfterSelf(outline); } else { cdata = outline.Descendants(ns + "T").FirstOrDefault().GetCData(); if (cdata != null) { cdata.Value = content; } } }
public static XElement Javascript(string content) { var cdata = new XCData("*/" + content + "/*"); var begin = new XText("/*"); var end = new XText("*/"); return(E("script", A("type", "text/javascript"), begin, cdata, end)); }
public static void SerializeSimpleValueToCDATA(this IExolutioSerializable component, [NotNull] string elementName, object value, XElement parentNode, SerializationContext context) { XElement xmlElement = new XElement(context.ExolutioNS + elementName); XCData xcData = new XCData(value.ToString()); xmlElement.Add(xcData); parentNode.Add(xmlElement); }
public static XCData WriteCData(this XElement parent, string data) { var cdata = new XCData(data); parent.Add(cdata); return(cdata); }
public static XElement SubElement( this XElement @this, string elementName, XCData value) { @this.Add(CreateNode(elementName, value)); return(@this); }
/// <summary> /// Gets the results as XML. /// </summary> /// <param name="results">The results.</param> /// <returns></returns> private static XPathNodeIterator GetResultsAsXml(ISearchResults results) { // create the XDocument XDocument doc = new XDocument(); // check there are any search results if (results.TotalItemCount > 0) { // create the root element XElement root = new XElement("nodes"); // iterate through the search results foreach (SearchResult result in results) { // create a new <node> element XElement node = new XElement("node"); // create the @id attribute XAttribute nodeId = new XAttribute("id", result.Id); // create the @score attribute XAttribute nodeScore = new XAttribute("score", result.Score); // add the content node.Add(nodeId, nodeScore); foreach (KeyValuePair <String, String> field in result.Fields) { // create a new <data> element XElement data = new XElement("data"); // create the @alias attribute XAttribute alias = new XAttribute("alias", field.Key); // assign the value to a CDATA section XCData value = new XCData(field.Value); // append the content data.Add(alias, value); // append the <data> element node.Add(data); } // add the node root.Add(node); } // add the root node doc.Add(root); } else { doc.Add(new XElement("error", "There were no search results.")); } return(doc.CreateNavigator().Select("/")); }
public string SignDocument(string xml) { var doc = new SignedXmlDocument(xml); CrytoProvider.SignDocument(doc); var cdata = new XCData(doc.ToString()); return(cdata.ToString()); }
public void CreateTextSimple() { Assert.Throws <ArgumentNullException>(() => new XCData((string)null)); XCData c = new XCData("foo"); Assert.Equal("foo", c.Value); Assert.Null(c.Parent); }
public static string NormalizeNewLines(XCData data) { if (ExecutionConditionUtil.IsWindows) { return(data.Value.Replace("\n", "\r\n")); } return(data.Value); }
protected VisualBasic.VisualBasicCompilation CreateVisualBasicCompilation( XCData code, VisualBasic.VisualBasicParseOptions parseOptions = null, VisualBasic.VisualBasicCompilationOptions compilationOptions = null, string assemblyName = null, IEnumerable <MetadataReference> referencedAssemblies = null) { return(CreateVisualBasicCompilation(assemblyName, code, parseOptions, compilationOptions, referencedAssemblies, referencedCompilations: null)); }
protected CSharp.CSharpCompilation CreateCSharpCompilation( XCData code, CSharp.CSharpParseOptions parseOptions = null, CSharp.CSharpCompilationOptions compilationOptions = null, string assemblyName = null, IEnumerable <MetadataReference> referencedAssemblies = null) { return(CreateCSharpCompilation(assemblyName, code, parseOptions, compilationOptions, referencedAssemblies, referencedCompilations: null)); }
private static XElement CreateElement(Type type, string name, object value) { if (type == typeof(string)) { XCData content = new XCData(value.ToString()); return(new XElement(name, content)); } return(new XElement(name, value)); }
protected void ParseChildNode(HtmlNode htmlNode, XElement resultElement, ParseContext parseContext, XElement baseFormattingElement) { if (parseContext.ParseDefinitions.IsEscapedNode(htmlNode)) { return; } ParseDefinition definition = parseContext.ParseDefinitions[htmlNode]; if (definition != null) { Type typeInfo = ReflectionUtil.GetTypeInfo(definition.HtmlParserType); if (typeInfo.Name == "CustomHtmlNodeParser") { var customParser = CustomHtmlParseHelper.GetParser <CustomHtmlNodeParser>(definition); if (customParser == null) { return; } customParser.SpecialCharacterMapper = SpecialCharacterMapper; customParser.ParseNode(htmlNode, resultElement, parseContext, baseFormattingElement); } else { object parser = CustomHtmlParseHelper.GetParser <HtmlNodeParser>(definition); ((HtmlNodeParser)parser)?.ParseNode(htmlNode, resultElement, parseContext, baseFormattingElement); } } else if (HtmlParseHelper.IsPlainTextNode(htmlNode)) { XCData xcData = new XCData(HtmlEntityHelper.DeEntitize(htmlNode.InnerHtml)); if (SpecialCharacterMapper != null) { SpecialCharacterMapper.ParseSpecialCharacters(xcData.Value, baseFormattingElement, ref resultElement); return; } if (baseFormattingElement != null) { XElement xelement = new XElement(baseFormattingElement); xelement.Add((object)xcData); resultElement.Add((object)xelement); } else { resultElement.Add(xcData); } } else { XElement formattingElement = StyleParser.GetFormattingElement(htmlNode, baseFormattingElement, true); this.ParseChildNodes(htmlNode, resultElement, parseContext, formattingElement); } }
public CompilationVerifier VerifyIL( string qualifiedMethodName, XCData expectedIL, bool realIL = false, string sequencePoints = null, [CallerFilePath] string callerPath = null, [CallerLineNumber] int callerLine = 0) { return(VerifyILImpl(qualifiedMethodName, expectedIL.Value, realIL, sequencePoints, callerPath, callerLine, escapeQuotes: false)); }
public void CData(string value1, string value2, bool checkHashCode) { XCData t1 = new XCData(value1); XCData t2 = new XCData(value2); VerifyComparison(checkHashCode, t1, t2); XElement e2 = new XElement("p2p", t2); e2.Add(t1); VerifyComparison(checkHashCode, t1, t2); }
// adds a cdata element public XElement AddCD(XElement parEl, string elName, string elValue) { XElement newEl = new XElement(elName); XCData cdEl = new XCData(elValue); newEl.Add(cdEl); parEl.Add(newEl); return(newEl); }
/// <summary> /// Copy ctor /// </summary> public XCData(XCData source) : base(source) { }
/// <summary> /// Initializes a new instance of the XCData class from another XCData object. /// </summary> /// <param name="other">Text node to copy from</param> public XCData(XCData other) : base(other) { }