public static XDocument TransformXML(XDocument doc, string xslPath) { XDocument newdoc = new XDocument(); using (XmlWriter writer = newdoc.CreateWriter()) { // Load the style sheet. XslCompiledTransform xslt = new XslCompiledTransform(); xslt.Load(XmlReader.Create(xslPath)); // Execute the transform and output the results to a writer. xslt.Transform(doc.CreateReader(), writer); } return newdoc; /* XslCompiledTransform transform = new XslCompiledTransform(); using (XmlReader reader = XmlReader.Create(xslPath)) { transform.Load(reader); } StringWriter results = new StringWriter(); transform.Transform(doc, null, results); var newdoc = new XmlDocument(); newdoc.LoadXml(results.ToString()); return newdoc; * */ }
public void GeneratePlainReport_1() { ReportModel model = ReportModel.Create(); ReportStructure reportStructure = new ReportStructure() { ReportLayout = GlobalEnums.ReportLayout.ListLayout }; IReportGenerator generator = new GeneratePlainReport(model,reportStructure); generator.GenerateReport(); XDocument doc1 = XDocument.Load(new XmlNodeReader (generator.XmlReport)); XDocument doc2 = new XDocument(); using (XmlWriter w = doc2.CreateWriter()){ generator.XmlReport.Save (w); } XDocument doc3 = ReportGenerationHelper.XmlDocumentToXDocument(generator.XmlReport); Assert.IsNotNull (doc1); Assert.IsNotNull (doc2); Assert.IsNotNull (doc2); var sq = from si in doc1.Descendants() select si; Console.WriteLine ("xxxxx"); foreach (XElement a in sq) { Console.WriteLine (a.Name); } }
/// <summary> /// Pulled from http://blogs.msdn.com/b/ericwhite/archive/2008/12/22/convert-xelement-to-xmlnode-and-convert-xmlnode-to-xelement.aspx /// </summary> /// <param name="node"></param> /// <returns></returns> internal static XElement GetXElement(this XmlNode node) { XDocument xDoc = new XDocument(); using (XmlWriter xmlWriter = xDoc.CreateWriter()) node.WriteTo(xmlWriter); return xDoc.Root; }
private void SerializeConfig() { var extraTypes = new Type[1]{typeof(AbstractConsumer)}; XDocument doc = new XDocument(new XDeclaration("1.0", "utf-8", "yes")); XmlSerializerNamespaces namespaces = new XmlSerializerNamespaces(); namespaces.Add(string.Empty, string.Empty); using(var writer = doc.CreateWriter()) { new XmlSerializer(typeof(configuration), extraTypes).Serialize(writer, config, namespaces); } doc.Element("configuration").Add( new XElement("controllers", new XElement("tcp", new XElement[2] { new XElement("port", 5250), new XElement("protocol", "AMCP") }))); doc.Add(new XComment(CasparCGConfigurator.Properties.Resources.configdoc.ToString())); using (var writer = new XmlTextWriter("casparcg.config", new UTF8Encoding(false, false))) // No BOM { writer.Formatting = Formatting.Indented; doc.Save(writer); } }
public static IGraph CreateNuspecGraph(XDocument nuspec, string baseAddress) { nuspec = NormalizeNuspecNamespace(nuspec); XslCompiledTransform transform = CreateTransform("xslt.nuspec.xslt"); XsltArgumentList arguments = new XsltArgumentList(); arguments.AddParam("base", "", baseAddress + "packages/"); arguments.AddParam("extension", "", ".json"); arguments.AddExtensionObject("urn:helper", new XsltHelper()); XDocument rdfxml = new XDocument(); using (XmlWriter writer = rdfxml.CreateWriter()) { transform.Transform(nuspec.CreateReader(), arguments, writer); } RdfXmlParser rdfXmlParser = new RdfXmlParser(); XmlDocument doc = new XmlDocument(); doc.Load(rdfxml.CreateReader()); IGraph graph = new Graph(); rdfXmlParser.Load(graph, doc); return graph; }
/// <summary> /// Provides an extension method that converts an /// XmlNode to a Linq XElement. /// </summary> /// <param name="node">the XmlNode</param> /// <returns>Linq XElement</returns> public static XElement GetXElement(this XmlNode node) { var xDoc = new XDocument(); using (var xmlWriter = xDoc.CreateWriter()) node.WriteTo(xmlWriter); return xDoc.Root; }
private static XElement GetXElement(XmlNode node) { var xDoc = new XDocument(); using (XmlWriter xmlWriter = xDoc.CreateWriter()) { node.WriteTo(xmlWriter); } return xDoc.Root; }
private XElement GetXElement(XmlNode node) { XDocument xDoc = new XDocument(); using (XmlWriter xmlWriter = xDoc.CreateWriter()) node.WriteTo(xmlWriter); return xDoc.Root; }
protected override async Task SendBodyAsync(IRequestContext context) { if (Xslt != null) { if (Model is XDocument) await TransformAsync(context, ((XDocument)Model).CreateNavigator()); else if (Model is IXPathNavigable) await TransformAsync(context, ((IXPathNavigable)Model)); else { var ser = Serializer ?? new XmlSerializer(Model.GetType()); var doc = new XDocument(); using (var writer = doc.CreateWriter()) ser.Serialize(writer, Model); await TransformAsync(context, doc.CreateNavigator()); } } else { using (var writer = context.Response.GetStreamWriter()) { if (Model is XDocument) ((XDocument)Model).Save(writer); else if (Model is XmlDocument) ((XmlDocument)Model).Save(writer); else if (Model is IXPathNavigable) using (var xWriter = new XmlTextWriter(writer)) ((IXPathNavigable)Model).CreateNavigator().WriteSubtree(xWriter); else (Serializer ?? new XmlSerializer(Model.GetType())) .Serialize(writer, Model); } } }
public override void Initialize() { base.Initialize(); List<Notice> list = new List<Notice>(); list.Add(new Notice() { Year = 1972, News = "PLATO IV: First computer with \n a touchable screen." }); list.Add(new Notice() { Year = 1985, News = "Home Manager: First home computer \n with a touchable screen." }); list.Add(new Notice() { Year = 1992, News = "SIMON. First smartphone." }); list.Add(new Notice() { Year = 1999, News = "Edge: Voting machine." }); list.Add(new Notice() { Year = 2000, News = "iPhone: Firts multitouch smartphone." }); XDocument doc = new XDocument(); XmlSerializer serializer = new XmlSerializer(typeof(List<Notice>)); System.Xml.XmlWriter writer = doc.CreateWriter(); serializer.Serialize(writer, list); writer.Close(); IsolatedStorage.SaveFile(doc, "myFile"); btGetNotice = new Button("Get next notice"); btGetNotice.Released += new Component.ComponentEventHandler(btnOpenBox_Released); AddComponent(btGetNotice, 50, 600); lblTime = new Label(list[0].Year.ToString()); lblNotice = new Label(list[0].News); AddComponent(lblTime, 50, 100); AddComponent(lblNotice, 50, 200); index = 1; }
/// <summary> /// Serializes the specified ParticleEffect instance. /// </summary> /// <param name="effect">The ParticleEffect to be serialized.</param> /// <param name="filename">The desired output file name,</param> public void Serialize(ParticleEffect effect, string filename) { // Create a new xml document... XDocument xmlDocument = new XDocument(); // Use the XNA serializer to populate the xml document... using (XmlWriter writer = xmlDocument.CreateWriter()) { IntermediateSerializer.Serialize<ParticleEffect>(writer, effect, ".\\"); } //// hack: Workaround for intermediate serializer not putting nodes in the right order... //foreach (XElement emitterElement in xmlDocument.Descendants("Asset").Elements("Item")) //{ // XElement releaseQuantityElement = emitterElement.Element("ReleaseQuantity"); // if ((releaseQuantityElement.PreviousNode as XElement).Name == "Name") // { // XElement termElement = emitterElement.Element("Term"); // termElement.AddAfterSelf(releaseQuantityElement); // releaseQuantityElement.Remove(); // } //} // Save the xml document... xmlDocument.Save(filename); }
public void ReadWrite() { var person = new Person() { Name = "duraid", Age = 35 }; person.Addresses.Add(new Address() { Street = "Decelles", City = "Montreal" }); person.Addresses.Add(new Address() { Street = "Lincoln", City = "Montreal" }); var map = new PersonMap(); var doc = new XDocument(); using (var writer = doc.CreateWriter()) { map.WriteXml(writer, person); } Person person2; using (var reader = doc.CreateReader()) { person2 = map.ReadXml(reader); } Assert.AreEqual(person.Name, person2.Name); Assert.AreEqual(person.Age, person2.Age); Assert.AreEqual(2, person.Addresses.Count); person.Addresses.Where(a => a.Street == "Decelles" && a.City == "Montreal").Single(); person.Addresses.Where(a => a.Street == "Lincoln" && a.City == "Montreal").Single(); }
public Stream GetPersonInfo(string id) { int personId = 0; int.TryParse(id, out personId); Person personFound = persons.FirstOrDefault(p => p.Id == personId); if (WebOperationContext.Current != null) WebOperationContext.Current.OutgoingResponse.ContentType = "text/html"; var reader = new StringReader(Resource.Style); XmlReader xreader = XmlReader.Create(reader); var xslt = new XslCompiledTransform(false); xslt.Load(xreader); var serializer = new XmlSerializer(typeof(Person)); var doc = new XDocument(); using (XmlWriter writer = doc.CreateWriter()) { if (personFound != null) serializer.Serialize(writer, personFound); } var outputWriter = new StringWriter(); xslt.Transform(doc.CreateNavigator(), null, outputWriter); string htmlEmailText = outputWriter.ToString(); var encoding = new System.Text.ASCIIEncoding(); var stream = new MemoryStream(encoding.GetBytes(htmlEmailText)); return stream; }
/// <summary> /// Perform another step in the word grammar debugging process and /// produce an html page showing the results /// </summary> /// <param name="nodeId">Id of the selected node to use</param> /// <param name="form"></param> /// <param name="lastUrl"></param> /// <returns>temporary html file showing the results of the next step</returns> public string PerformAnotherWordGrammarDebuggerStepPage(string nodeId, string form, string lastUrl) { m_xmlHtmlStack.Push(Tuple.Create(m_wordGrammarDebuggerXml, lastUrl)); var doc = new XDocument(); using (XmlWriter writer = doc.CreateWriter()) CreateSelectedWordGrammarXml(writer, nodeId, form); return CreateWordDebuggerPage(doc); }
/// <summary> /// Initialize what is needed to perform the word grammar debugging and /// produce an html page showing the results /// </summary> /// <param name="nodeId">Id of the node to use</param> /// <param name="form">the wordform being tried</param> /// <param name="lastUrl"></param> /// <returns>temporary html file showing the results of the first step</returns> public string SetUpWordGrammarDebuggerPage(string nodeId, string form, string lastUrl) { m_xmlHtmlStack.Push(Tuple.Create((XDocument) null, lastUrl)); var doc = new XDocument(); using (XmlWriter writer = doc.CreateWriter()) CreateAnalysisXml(writer, nodeId, form); return CreateWordDebuggerPage(doc); }
/// <summary> /// 将XmlNode转换为XElement /// </summary> /// <returns> XElment对象 </returns> public static XElement ToXElement(this XmlNode node) { var xdoc = new XDocument(); using (var xmlWriter = xdoc.CreateWriter()) { node.WriteTo(xmlWriter); } return xdoc.Root; }
static XDocument NormalizeNuspecNamespace(XDocument original, XslCompiledTransform xslt) { XDocument result = new XDocument(); using (XmlWriter writer = result.CreateWriter()) { xslt.Transform(original.CreateReader(), writer); } return result; }
public static XDocument XmlDocumentToXDocument (XmlDocument xmlDoc) { XDocument xDoc = new XDocument(); using (XmlWriter w = xDoc.CreateWriter()){ xmlDoc.Save (w); } return xDoc; }
public static XElement SerializeAsXElement(this XmlSerializer xs, object o) { XDocument d = new XDocument(); using (XmlWriter w = d.CreateWriter()) { xs.Serialize(w, o); } XElement e = d.Root; e.Remove(); return e; }
/// <summary> /// Serializes the specified particle effect to the specified file path. /// </summary> /// <param name="particleEffect">The particle effect to be serialized.</param> /// <param name="filePath">The path to the desired output file.</param> public void Serialize(ParticleEffect particleEffect, string filePath) { XDocument xmlDocument = new XDocument(); using (XmlWriter writer = xmlDocument.CreateWriter()) { IntermediateSerializer.Serialize<ParticleEffect>(writer, particleEffect, ".\\"); } xmlDocument.Save(filePath); }
public void CsdlSerializer_serializes_custom_model_namespace() { var serializedModel = new XDocument(); using (var writer = serializedModel.CreateWriter()) { new CsdlSerializer() .Serialize(new EdmModel(DataSpace.CSpace), writer, "NS"); } Assert.Equal("NS", (string)serializedModel.Root.Attribute("Namespace")); }
public void Serialize_should_return_valid_edmx_xml_v3() { var databaseMapping = CreateSimpleModel(3.0); var edmx = new XDocument(); using (var xmlWriter = edmx.CreateWriter()) { new EdmxSerializer().Serialize(databaseMapping, ProviderRegistry.Sql2008_ProviderInfo, xmlWriter); } edmx.Validate(LoadEdmxSchemaSet(3), (_, e) => { throw e.Exception; }); }
public void Serialize_should_return_valid_edmx_xml_v3() { var databaseMapping = CreateSimpleModel(XmlConstants.StoreVersionForV3); var edmx = new XDocument(); using (var xmlWriter = edmx.CreateWriter()) { new EdmxSerializer().Serialize(databaseMapping, xmlWriter); } edmx.Validate(LoadEdmxSchemaSet(3), (_, e) => { throw e.Exception; }); }
private static XElement GetXElement(string queueMessagesListXml) { XmlDocument xmlDocument = new XmlDocument(); xmlDocument.LoadXml(queueMessagesListXml); XDocument xdocument = new XDocument(); using (XmlWriter xmlWriter = xdocument.CreateWriter()) { xmlDocument.WriteTo(xmlWriter); } return xdocument.Root; }
public static XElement Transform(this XElement element, string xsl) { if (xsl.IsNullOrEmpty()) return element; var document = new XDocument(); using (var writer = document.CreateWriter()) { var xslt = new XslCompiledTransform(); xslt.Load(XmlReader.Create(new StringReader(xsl))); xslt.Transform(element.CreateNavigator(), writer); } return document.Root; }
private XDocument TransformMarkup(XElement inputRoot) { var newTree = new XDocument(); using (XmlWriter writer = newTree.CreateWriter()) { var xslTransformer = new XslCompiledTransform(); xslTransformer.LoadFromPath(this.MapPath(XsltFileName)); xslTransformer.Transform(inputRoot.CreateReader(), writer); } return newTree; }
//Returns result serialized as xml public ActionResult AnXmlresult() { var obj = new ExampleClass { ExampleProperty = "Something..." }; var xdoc = new XDocument(); using (var writer = xdoc.CreateWriter()) { var serializer = new DataContractSerializer(obj.GetType()); serializer.WriteObject(writer, obj); //Serialize object to xml } return Content(xdoc.ToString(), "text/xml"); }
public void Render(ViewContext viewContext, TextWriter writer) { var xmlDoc = viewContext.ViewData.Model as XDocument; if(xmlDoc==null) { var xs = new XmlSerializer(viewContext.ViewData.Model.GetType()); xmlDoc = new XDocument(); using (var xWriter = xmlDoc.CreateWriter()) { xs.Serialize(xWriter, viewContext.ViewData.Model); } } _template.Transform(xmlDoc.CreateReader(),null,writer); }
public void WriteEmptyElements () { var doc = new XDocument (); XmlWriter w = doc.CreateWriter (); w.WriteStartElement ("root"); w.WriteStartElement ("foo"); w.WriteEndElement (); w.WriteStartElement ("bar"); w.WriteFullEndElement (); w.WriteEndElement (); w.Close (); Assert.IsTrue (((XElement) doc.Root.FirstNode).IsEmpty, "#1"); Assert.IsFalse (((XElement) doc.Root.LastNode).IsEmpty, "#2"); }
public XElement GenerateDiffGram(XElement element1, XElement element2) { using (var node1Reader = element1.CreateReader()) using (var node2Reader = element2.CreateReader()) { var result = new XDocument(); using (var writer = result.CreateWriter()) { var diff = new XmlDiff(XmlDiffOptions.IgnoreChildOrder | XmlDiffOptions.IgnoreWhitespace | XmlDiffOptions.IgnoreComments | XmlDiffOptions.IgnoreXmlDecl); diff.Compare(node1Reader, node2Reader, writer); writer.Flush(); writer.Close(); } return result.Root; } }