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;
}
}
