protected void Page_Load(object sender, EventArgs e)
{
string xslFile = Server.MapPath("DvdList.xsl");
string xmlFile = Server.MapPath("DvdList.xml");
string htmlFile = Server.MapPath("DvdList.htm");
XslTransform transf = new XslTransform();
transf.Load(xslFile);
transf.Transform(xmlFile, htmlFile);
// Create an XPathDocument.
XPathDocument xdoc = new XPathDocument(new XmlTextReader(xmlFile));
// Create an XPathNavigator.
XPathNavigator xnav = xdoc.CreateNavigator();
// Transform the XML
XmlReader reader = transf.Transform(xnav, null);
// Go the the content and write it.
reader.MoveToContent();
Response.Write(reader.ReadOuterXml());
reader.Close();
}
private void Images()
{
// Dataset containing
string catname ="Electricals";
ProductImageService.serProdctImage prodimage = new ProductImageService.serProdctImage();
DataSet dataset = prodimage.ProductImage_GetFashImgtwoForHandler(catname);
//string x = dataset.GetXml();
string xmlfile = dataset.GetXml();
XslTransform xslt = new XslTransform();
xslt.Load(Server.MapPath("~/xslt/HomeXSLTFile.xslt"));
XPathDocument xpathdocument = new
XPathDocument(xmlfile);
XmlTextWriter writer = new XmlTextWriter(Console.Out);
writer.Formatting = Formatting.Indented;
xslt.Transform(xpathdocument, null, writer, null);
//strstudentDetails = GetHtml(Server.MapPath("~/xsl/studentDetails.xsl"), strXML);
//XPathDocument myXPathDoc = new XPathDocument(myXmlFile);
//XslCompiledTransform myXslTrans = new XslCompiledTransform();
//myXslTrans.Load(myStyleSheet);
//XmlTextWriter myWriter = new XmlTextWriter("result.html", null);
//myXslTrans.Transform(myXPathDoc, null, myWriter);
}
public void Action() {
string xml = "<?xml version=\"1.0\"?>\n<a><b c=\"d\">e</b></a>";
string xsl = "<?xml version=\"1.0\"?>\n" +
"<xsl:stylesheet version=\"1.0\" " +
"xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" " +
"xmlns:msxsl=\"urn:schemas-microsoft-com:xslt\" " +
"xmlns:js=\"urn:js\" " +
">" +
"<msxsl:script language=\"jsCrIpt\" implements-prefix=\"js\">" +
"function SimpleTest() { return \"JScript test\"; }" +
"</msxsl:script>" +
"<xsl:template match=\"a\"><foo><xsl:apply-templates/></foo></xsl:template>" +
"<xsl:template match=\"b\"><xsl:element name=\"bar\">" +
"<xsl:attribute name=\"simpleTest\"><xsl:value-of select=\"js:SimpleTest()\"/></xsl:attribute>" +
"</xsl:element></xsl:template>" +
"<xsl:template match=\"/\"><xsl:apply-templates/></xsl:template>" +
"</xsl:stylesheet>";
XPathDocument myXPathDocument = new XPathDocument(new XmlTextReader(new StringReader(xml)));
XslTransform myXslTransform = new XslTransform();
myXslTransform.Load(new XmlTextReader(new StringReader(xsl)));
StringWriter myStringWriter = new StringWriter();
XmlTextWriter myXmlWriter = new XmlTextWriter(myStringWriter);
myXmlWriter.Formatting = Formatting.Indented;
myXslTransform.Transform(myXPathDocument, null, myXmlWriter);
myXmlWriter.Close();
Console.WriteLine(myStringWriter.ToString());
}
static void Main(string[] args)
{
try
{
if (args.Length < 2)
{
Console.WriteLine("usage: <gedcomFileName> <xmlOutputFileName> [-s <xsltFileName>]");
return;
}
string gedcomFileName = args[0];
string outputFileName = args[1];
string xsltFileName = "";
GedcomReader gr = new GedcomReader(gedcomFileName);
XmlDocument doc = new XmlDocument();
doc.Load(gr);
gr.Close();
if (args.Length > 3 && args[2].Equals("-s"))
{
xsltFileName = args[3];
XslTransform tx = new XslTransform();
tx.Load(xsltFileName);
FileStream fs = new FileStream(outputFileName, FileMode.Create);
tx.Transform(doc, null, fs, null);
}
else
doc.Save(args[1]);
}
catch(Exception e)
{
Console.WriteLine("###error: {0}", e.Message);
}
}
} //Main()
/// <summary>
/// Demonstrates the XslTransform class using two different overloads.
/// One returns an XmlReader containing the transform.
/// The other stores the transform in an XmlTextWriter.
/// </summary>
/// <param name="document"></param>
/// <param name="stylesheet"></param>
public static void ReadTransformWrite(string document, string stylesheet)
{
StreamReader stream = null;
try
{
string outputFile = Path.GetFileNameWithoutExtension(document) + "_transform.xml";
// XPathDocument stores the target XML in an efficient way for transformation.
XPathDocument myXPathDocument = new XPathDocument(document);
XslTransform myXslTransform = new XslTransform();
myXslTransform.Load(stylesheet);
// Get back the transform results in an XMLReader and output them to the console.
XmlReader reader = myXslTransform.Transform(myXPathDocument, null);
Console.WriteLine("Input XML file: {0} \nXSL stylesheet: {1}" + nl, document, stylesheet);
Console.WriteLine(nl + "Layout of transformed XML content from XML reader:" + nl);
OutputXml(reader);
// Create an output file to hold the tranform.
// Using an intermediate XmlTextWriter instead of the overload of the Transform method
// that writes directly to a file allows more control of the formatting.
XmlTextWriter writer = new XmlTextWriter(outputFile, null);
writer.Formatting = Formatting.Indented;
writer.Indentation = 2;
myXslTransform.Transform(myXPathDocument, null, writer);
writer.Close();
//Output the contents of the tranformed file to the console.
Console.WriteLine(nl + "Transformed XML content from file:" + nl);
stream = new StreamReader (outputFile);
Console.Write(stream.ReadToEnd());
} //try
catch (Exception e)
{
Console.WriteLine ("Exception: {0}", e.ToString());
} //catch
finally
{
if (stream != null)
stream.Close();
} //finally
} //ReadTransformWrite()
private void button3_Click(object sender, EventArgs e)
{
xsltFilename = "transformer.xslt";
xmlFilename = "catalog.xml";
var xslt = new XslTransform();
xslt.Load(xsltFilename);
xslt.Transform(xmlFilename, "final.html");
}
public void XsltLoadWithPayload()
{
var xsl = new XslTransform();
Pattern.CreateByName(it => xsl.Load(it.IsPayloadFrom("MsxslScript.xsl").Cast <XmlReader>()));
var document = new XPathDocument(new StringReader("<?xml version='1.0'?><data></data>"));
Pattern.CreateByName(it => xsl.Transform(document, null, TextWriter.Null, null));
}
// Perform an XSLT transformation where xsltNav is an XPathNavigator containing
// a stylesheet from an untrusted source.
//<snippet1>
public static void TransformFile(XPathNavigator xsltNav)
{
// Load the stylesheet.
XslTransform xslt = new XslTransform();
xslt.Load(xsltNav, null, null);
// Transform the file.
xslt.Transform("books.xml", "books.html", null);
}
// Perform an XSLT transformation where xsltReader is an XmlReader containing
// a stylesheet and secureURI is a trusted URI that can be used to create Evidence.
//<snippet1>
public static void TransformFile(XmlReader xsltReader, String secureURL)
{
// Load the stylesheet using a default XmlUrlResolver and Evidence
// created using the trusted URL.
XslTransform xslt = new XslTransform();
xslt.Load(xsltReader, new XmlUrlResolver(), XmlSecureResolver.CreateEvidenceForUrl(secureURL));
// Transform the file.
xslt.Transform("books.xml", "books.html", new XmlUrlResolver());
}
static void Transform(string [] args)
{
XslTransform t = new XslTransform();
t.Load(args [1]);
TextWriter output = args.Length > 3 ?
File.CreateText(args [3]) : Console.Out;
t.Transform(new XPathDocument(args [2], XmlSpace.Preserve), null, output, null);
output.Close();
}
private void CreateSummaryDocument(string xmlOutput, XmlTextReader transformReader)
{
XPathDocument originalXPathDocument = new XPathDocument(new StringReader(xmlOutput));
XslTransform summaryXslTransform = new XslTransform();
// Using obsolete form for now, remove warning suppression from project after changing
summaryXslTransform.Load(transformReader);
// Using obsolete form for now, remove warning suppression from project after changing
summaryXslTransform.Transform(originalXPathDocument, null, Console.Out);
}
internal static void Main()
{
/* this is deprecated, but only for homework purposes */
XslTransform sheetTransrormer = new XslTransform();
sheetTransrormer.Load("../../../styleXSLT.xslt");
sheetTransrormer.Transform("../../../catalogue.xml", "../../transformedCatalogue.html");
Console.WriteLine("Result is in folder solution.");
/*I leave on you to find difference with last task...*/
}
static void Main(string[] args)
{
XmlUrlResolver resolver = new XmlUrlResolver();
resolver.Credentials = System.Net.CredentialCache.DefaultCredentials;
// transform xml file to HTML file
XslTransform transform = new XslTransform();
transform.Load(@"..\..\XSLT_Transformation.xslt", resolver);
transform.Transform(@"..\..\XML_Report.xml", @"..\..\..\..\..\HTML_Report.html", resolver);
}
private void CreateSummaryDocument(string resultFile, TextWriter writer, NUnit2Test test)
{
XPathDocument originalXPathDocument = new XPathDocument(resultFile);
// Using XslTransform instead of XslCompiledTransform because the latter
// does not display nunit output for unknown reasons.
XslTransform summaryXslTransform = new XslTransform();
XmlTextReader transformReader = GetTransformReader(test);
summaryXslTransform.Load(transformReader);
summaryXslTransform.Transform(originalXPathDocument, null, writer);
}
public static string TransformXMLStream(string xmlStream, string xslPath)
{
XmlDocument xmlDoc = new XmlDocument();
XslTransform xslDoc = new XslTransform();
xmlDoc.LoadXml(xmlStream);
xslDoc.Load(xslPath);
StringWriter sw = new StringWriter();
xslDoc.Transform(xmlDoc, null, sw);
return(sw.GetStringBuilder().ToString());
}
/* Methode zum Transformieren eines XML-Dokuments
* mit einem XSLT-Dokument */
public static void TransformXmlFile(string xmlSourceFileName,
string xslFileName, string xmlDestFileName)
{
// Instanz der Klasse XslTransform erzeugen
XslTransform xslTransform = new XslTransform();
// XSL-Datei laden
xslTransform.Load(xslFileName);
// XML-Datei transformieren
xslTransform.Transform(xmlSourceFileName, xmlDestFileName);
}
// Function : Export_with_XSLT_Web
// Arguments : dsExport, sHeaders, sFileds, FormatType, FileName
// Purpose : Exports dataset into CSV / Excel format
private void Export_with_XSLT_Web(DataSet dsExport, string[] sHeaders, string[] sFileds, ExportFormat FormatType,
string FileName)
{
try
{
// Appending Headers
response.Clear();
response.Buffer = true;
if (FormatType == ExportFormat.CSV)
{
response.ContentType = "text/csv";
response.AppendHeader("content-disposition", "attachment; filename=" + FileName);
}
else
{
response.ContentType = "application/vnd.ms-excel";
response.AppendHeader("content-disposition", "attachment; filename=" + FileName);
}
// XSLT to use for transforming this dataset.
MemoryStream stream = new MemoryStream();
XmlTextWriter writer = new XmlTextWriter(stream, Encoding.UTF8);
CreateStylesheet(writer, sHeaders, sFileds, FormatType);
writer.Flush();
stream.Seek(0, SeekOrigin.Begin);
XmlDataDocument xmlDoc = new XmlDataDocument(dsExport);
//dsExport.WriteXml("Data.xml");
XslTransform xslTran = new XslTransform();
xslTran.Load(new XmlTextReader(stream), null, null);
StringWriter sw = new StringWriter();
xslTran.Transform(xmlDoc, null, sw, null);
//xslTran.Transform(System.Web.HttpContext.Current.Server.MapPath("Data.xml"), null, sw, null);
//Writeout the Content
response.Write(sw.ToString());
sw.Close();
writer.Close();
stream.Close();
response.End();
}
catch (ThreadAbortException Ex)
{
string ErrMsg = Ex.Message;
}
catch (Exception Ex)
{
throw Ex;
}
}
public static void Main(string [] rgstrArgs)
{
XmlDocument xml = new XmlDocument();
xml.Load(rgstrArgs [0]);
XslTransform xsl = new XslTransform();
xsl.Load(rgstrArgs [1]);
xsl.Transform(xml, null, Console.Out);
}
public static void Transformar()
{
XslTransform xslt = new XslTransform();
xslt.Load(stylesheet);
XPathDocument xpathdocument = new XPathDocument(filename);
XmlTextWriter writer = new XmlTextWriter(Console.Out);
writer.Formatting = Formatting.Indented;
xslt.Transform(xpathdocument, null, writer, null);
}
public static string ApplyOld(string xslFileName, string fileFullName)
{
XslTransform xsltE = new XslTransform();
XPathDocument xpdXml = new XPathDocument(fileFullName);
XPathDocument xpdXslt = new XPathDocument(xslFileName);
xsltE.Load(xpdXslt, new XmlUrlResolver(), System.Reflection.Assembly.GetCallingAssembly().Evidence);
StringWriter result = new StringWriter();
xsltE.Transform(xpdXml, null, result, null);
return(result.ToString());
}
public static void ToHtml(this string dita, string saveTo, string outputpath)
{
XmlDocument doc = new XmlDocument();
doc.LoadXml(dita);
doc.Save(saveTo);
XslTransform myXslTransform;
myXslTransform = new XslTransform();
myXslTransform.Load("XSLTs/tool.xsl");
myXslTransform.Transform(saveTo, outputpath);
}
// Problem 14 - Write a C# program to apply the XSLT stylesheet transformation on the file catalog.xml using the class XslTransform.
private static void ApplyXsltTransformation(string filePath)
{
Console.WriteLine("Problem 14: ");
XslTransform myXslTransform;
myXslTransform = new XslTransform();
myXslTransform.Load("../../files/catalog.xslt");
myXslTransform.Transform(filePath, "../../files/catalog.html");
Console.WriteLine("Result is in catalog.html");
}
/// <summary>
/// The Page_Load event handler on this User Control uses
/// the Portal configuration system to obtain an xml document
/// and xsl/t transform file location.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Page_Load(object sender, System.EventArgs e)
{
XslTransform xs;
XPathDocument xd;
XsltArgumentList xa = new XsltArgumentList();
XslHelper xh = new XslHelper();
StringBuilder sb = new StringBuilder();
TextWriter tw = new StringWriter(sb);
PortalUrlDataType pt;
pt = new PortalUrlDataType();
pt.Value = Settings["XMLsrc"].ToString();
string xmlsrc = Server.MapPath(pt.FullPath);
pt = new PortalUrlDataType();
pt.Value = Settings["XSLsrc"].ToString();
string xslsrc = Server.MapPath(pt.FullPath);
if ((xmlsrc != null) && (xmlsrc != string.Empty) &&
(xslsrc != null) && (xslsrc != string.Empty) &&
File.Exists(xmlsrc) &&
File.Exists(xslsrc))
{
xd = new XPathDocument(xmlsrc);
xs = new XslTransform();
xs.Load(xslsrc);
xa.AddParam("Lang", string.Empty, this.portalSettings.PortalContentLanguage.Name.ToLower());
xa.AddExtensionObject("urn:rainbow", xh);
#if FW11
xs.Transform(xd, xa, tw, new XmlUrlResolver());
#else
xs.Transform(xd, xa, tw);
#endif
this.Content = sb.ToString();
this.ContentHolder.Controls.Add(new LiteralControl(this.Content.ToString()));
this.ModuleConfiguration.CacheDependency.Add(xslsrc);
this.ModuleConfiguration.CacheDependency.Add(xmlsrc);
}
}
public void Load(string xmlUri, string xslUri, string xsdUri)
{
var xslTransform = new XslTransform();
xslTransform.Load(xslUri);
var xmlDocument = new XmlDocument();
xmlDocument.Load(xmlUri);
var resultStream = new MemoryStream();
xslTransform.Transform(xmlDocument, new XsltArgumentList(), resultStream);
resultStream.Position = 0;
// check via XSD.
try
{
Console.WriteLine("Validating XML");
var settings = new XmlReaderSettings();
settings.NameTable = new NameTable();
var nsManager = new XmlNamespaceManager(settings.NameTable);
nsManager.AddNamespace("", "http://stroop.mine.nu/xsd/OpenTemplater");
var xmlParserContext = new XmlParserContext(settings.NameTable, nsManager, "", XmlSpace.Default);
settings.Schemas.Add(null, xsdUri);
settings.ValidationType = ValidationType.Schema;
settings.ValidationEventHandler += XsdValidationHandler;
var document = new XmlDocument();
document.Load(resultStream);
XmlReader rdr = XmlReader.Create(new StringReader(document.InnerXml), settings, xmlParserContext);
while (rdr.Read())
{
}
document.Save("F:\\debug.xml");
Console.WriteLine("Succesfully validated XML.");
var dataDocument = new XmlDocumentDefinition(document);
Load(dataDocument);
}
catch (XmlSchemaValidationException ex)
{
}
}
public static void XsltTransform(string xslPath, string xmlPath, string htmlPath)
{
XslTransform xslt = new XslTransform();
xslt.Load(xslPath);
XPathDocument mydata = new XPathDocument(xmlPath);
using (FileStream fs = new FileStream(htmlPath, FileMode.OpenOrCreate))
{
xslt.Transform(mydata, null, fs, null);
}
}
static void Main()
{
XsltArgumentList args = new XsltArgumentList();
args.AddExtensionObject("my-namespace", new MyExtensionObject());
XslTransform xslt = new XslTransform();
xslt.Load("foo.xslt");
using (TextWriter output = File.CreateText("out.txt")) {
XPathDocument input = new XPathDocument("foo.xml");
xslt.Transform(input, args, output);
}
}
public static void Main()
{
//<snippet1>
//Create the XslTransform object.
XslTransform xslt = new XslTransform();
//Load the stylesheet.
xslt.Load("output.xsl");
//Transform the file.
xslt.Transform("books.xml", "books.html");
//</snippet1>
}
private string TransformElements(string source)
{
XPathDocument doc = new XPathDocument(
new StringReader("<root>" + source + "</root>"));
XslTransform tr = new XslTransform();
tr.Load("wiki2ecmahelper.xsl");
XmlReader reader = tr.Transform(doc, null, (XmlResolver)null);
reader.Read(); // should consume <root> start tag
return(reader.ReadInnerXml());
}
public /* AddResponse */ void Add(/* Add Add1 */)
{
XmlValidatingReader valid = new XmlValidatingReader(new XmlTextReader(SoapStreams.InputMessage));
valid.Schemas.Add(XmlSchema.Read(new XmlTextReader(HttpContext.Current.Server.MapPath("server.xsd")), null));
XmlDocument doc = new XmlDocument();
doc.Load(valid);
XslTransform transform = new XslTransform();
transform.Load(new XmlTextReader(HttpContext.Current.Server.MapPath("add.xslt")));
transform.Transform(doc, null, new XmlTextWriter(SoapStreams.OutputMessage, Encoding.UTF8));
}
//==============================
//
static void XSLT_Roundtrip_Old()
{
//<snippet17>
// Execute the transformation.
XslTransform xslt = new XslTransform();
xslt.Load("output.xsl");
XmlReader reader = xslt.Transform(new XPathDocument("books.xml"), null, new XmlUrlResolver());
// Load the results into an XPathDocument object.
XPathDocument doc = new XPathDocument(reader);
//</snippet17>
}
// you could have other overloads if you want to get creative...
public static string CreateWorkbook(DataSet ds, string xsl)
{
XmlDataDocument xmlDataDoc = new XmlDataDocument(ds);
XslTransform xt = new XslTransform();
StreamReader reader = new StreamReader(xsl);
XmlTextReader xRdr = new XmlTextReader(reader);
xt.Load(xRdr, null, null);
StringWriter sw = new StringWriter();
xt.Transform(xmlDataDoc, null, sw, null);
return(sw.ToString());
}
} //Pokaż listę odcinków z pliku XML
private void btnToHTML_Click(object sender, EventArgs e)
{
DialogResult dr = saveFileDialog.ShowDialog();
if (dr == System.Windows.Forms.DialogResult.OK)
{
XPathDocument myXPathDoc = new XPathDocument(Friends_from_MegaVideo_player.Properties.Settings.Default.FilePath);
XslTransform myXslTrans = new XslTransform(); //Musi być
myXslTrans.Load(System.IO.Path.GetDirectoryName(Friends_from_MegaVideo_player.Properties.Settings.Default.FilePath) + @"\Przyjaciele.xsl");
XmlTextWriter myWriter = new XmlTextWriter(saveFileDialog.FileName, Encoding.Unicode);
myXslTrans.Transform(myXPathDoc, null, myWriter);
}
} //Eksportuj listę z pliku XML do HTML przy użyciu stylów z pliku XSL
private static string CreateWorkbook(DataSet ds)
{
XmlDataDocument xmlDataDoc = new XmlDataDocument(ds);
XslTransform xt = new XslTransform();
StreamReader reader = new StreamReader(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Excel.xsl"));
XmlTextReader xRdr = new XmlTextReader(reader);
xt.Load(xRdr, null, null);
StringWriter sw = new StringWriter();
xt.Transform(xmlDataDoc, null, sw, null);
return(sw.ToString());
}
public static string ApplyToString(string xml, string xslFileName)
{
XslTransform xsltE = new XslTransform();
StringReader srXml = new StringReader(xml);
XPathDocument xpdXml = new XPathDocument(srXml);
XPathDocument xpdXslt = new XPathDocument(xslFileName);
xsltE.Load(xpdXslt, null, System.Reflection.Assembly.GetCallingAssembly().Evidence);
StringWriter result = new StringWriter();
xsltE.Transform(xpdXml, null, result, null);
return(result.ToString());
}
private void Export_with_XSLT_Web(DataSet dsExport, string[] sHeaders, string[] sFileds, ExportFormat FormatType, string FileName)
{
try
{
//读取要存进Excel报表中的内容
MemoryStream w = new MemoryStream();
XmlTextWriter writer = new XmlTextWriter(w, Encoding.Default);
this.CreateStylesheet(writer, sHeaders, sFileds, FormatType);
writer.Flush();
w.Seek(0L, SeekOrigin.Begin);
XmlDataDocument document = new XmlDataDocument(dsExport);
XslTransform transform = new XslTransform();
transform.Load(new XmlTextReader(w), null, null);
StringWriter writer2 = new StringWriter();
transform.Transform((IXPathNavigable)document, null, (TextWriter)writer2, null);
/*
* 保存临时Excel供下载
*/
string _TempFilePath = "~/business/report/down/" + FileName; // +".xls";
string _FilePath = HttpContext.Current.Server.MapPath(_TempFilePath);
FileStream oFileStream;
if (!File.Exists(_FilePath))
{
oFileStream = new FileStream(_FilePath, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
}
else
{
//休眠一秒 避免文件未删除完就开始创建产生冲突
Thread.Sleep(1000);
oFileStream = new FileStream(_FilePath, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
//oFileStream = new FileStream(_FilePath, FileMode.Append, FileAccess.Write, FileShare.ReadWrite);
}
StreamWriter oStreamWriter = new StreamWriter(oFileStream, Encoding.Default);
oStreamWriter.Write(writer2.ToString());
oStreamWriter.Close();
oFileStream.Close();
writer2.Close();
writer.Close();
w.Close();
}
catch (ThreadAbortException exception)
{
string message = exception.Message;
}
catch (Exception exception2)
{
throw exception2;
}
}
protected virtual void OnConvert (object sender, System.EventArgs e)
{
XmlDocument xsltdoc = new XmlDocument();
Stream s = Assembly.GetExecutingAssembly().GetManifestResourceStream("svg2xaml.xslt");
xsltdoc.Load (s);
XslTransform t = new XslTransform();
t.Load (xsltdoc);
t.Transform (svgFilename, svgFilename + ".xaml");
FileStream file = File.OpenRead(svgFilename + ".xaml");
using (StreamReader sr = new StreamReader (file))
xaml.Append(sr.ReadToEnd ());
file.Close();
RefreshXaml();
}
/// <summary>
/// XML ファイルに XSLT を適用。
/// </summary>
static void ApplyXsl(string fileName)
{
string xslName = GetXSlUri(fileName);
if(xslName == null)
return;
xslName = Path.GetDirectoryName(fileName) + @"\" + xslName.Replace('/', '\\');
string htmlName = Path.ChangeExtension(fileName, ".html");
Console.Write("xml : {0}\nxsl : {1}\nhtml:{2}\n\n", fileName, xslName, htmlName);
XslTransform xslt = new XslTransform();
xslt.Load(xslName);
xslt.Transform(fileName, htmlName);
}
//This will transform xml document using xslt and produce result xml document
//and display it
public static void Main(string[] args)
{
try
{
XPathDocument myXPathDocument = new XPathDocument("C:/Users/user/Desktop/Assignment 4/schema.xml");
XslTransform myXslTransform = new XslTransform();
XmlTextWriter writer = new XmlTextWriter("C:/Users/user/Desktop/Assignment 4/output.html", null);
myXslTransform.Load("http://www.public.asu.edu/~sprakas3/dsod/Hotels.xsl");
myXslTransform.Transform(myXPathDocument, null, writer);
writer.Close();
StreamReader stream = new StreamReader("C:/Users/user/Desktop/Assignment 4/output.html");
Console.Write("**This is result document**\n\n");
Console.Write(stream.ReadToEnd());
}
catch (Exception e)
{
}
}
public static void Main(string[] args)
{
try
{
String xmlDoc = "C:\\Path\\To\\Input.xml"
String xslDoc = "C:\\Path\\To\\XSLT_Script.xsl"
String newDoc = "C:\\Path\\To\\Output.xml"
XPathDocument myXPathDocument = new XPathDocument(xmlDoc);
XslTransform myXslTransform = new XslTransform();
myXslTransform.Load(xslDoc);
myXslTransform.Transform(myXPathDocument, newDoc);
}
catch (Exception e)
{
Console.WriteLine ("Exception: {0}", e.ToString());
}
}
private void ParseResponse(string response)
{
XmlDocument doc = null;
XslTransform myXslTransform = null;
StringWriter sw = null;
try
{
doc = new XmlDocument(); ;
myXslTransform = new XslTransform();
sw = new StringWriter();
doc.LoadXml(response);
myXslTransform.Load("C:\\Users\\simona.EDUSOFT2\\Documents\\Visual Studio 2013\\WebSites\\WebSite1\\transform.xsl");
myXslTransform.Transform(doc, null, sw);
string result = sw.ToString().Replace("xmlns:asp=\"remove\"",
"").Replace("<", "<").Replace(">", ">");
Control control = Page.FindControl("MyTable");
if (control != null)
{
Page.Controls.Remove(control);
}
Control ctrl = Page.ParseControl(result);
Page.Controls.Add(ctrl);
MyPanel.Visible = false;
}
catch
{
//parsing or loading error
displayErrorMessage(errorParsingOrLoading);
}
finally
{
sw.Close();
}
}
public static void Main(string[] args)
{
Opts opts = new Opts();
opts.ProcessArgs(args);
if (opts.RemainingArguments.Length != 2 && opts.RemainingArguments.Length != 3) {
opts.DoHelp();
return;
}
string datasource, rootentity, stylesheetfile;
if (opts.RemainingArguments.Length == 2) {
datasource = opts.RemainingArguments[0];
rootentity = null;
stylesheetfile = opts.RemainingArguments[1];
} else {
datasource = opts.RemainingArguments[0];
rootentity = opts.RemainingArguments[1];
stylesheetfile = opts.RemainingArguments[2];
}
XsltArgumentList xsltargs = new XsltArgumentList();
if (opts.param != null)
foreach (string p in opts.param) {
int eq = p.IndexOf('=');
if (eq == -1) {
Console.Error.WriteLine("Param arguments must be name=value.");
return;
}
string n = p.Substring(0, eq);
string v = p.Substring(eq+1);
xsltargs.AddParam(n, "", v);
}
XmlDocument sty = new XmlDocument();
sty.PreserveWhitespace = true;
sty.Load(stylesheetfile);
XslTransform t = new XslTransform();
t.Load(sty, null, null);
NamespaceManager nsmgr = new NamespaceManager();
// Scan xmlsn: attributes in the stylesheet node.
// For all namespaces of the form assembly://assemblyname/TypeName, load in
// the methods of that type as extension functions in that namespace.
// And add xmlns declarations to nsmgr.
foreach (XmlAttribute a in sty.DocumentElement.Attributes) {
if (!a.Name.StartsWith("xmlns:")) continue;
nsmgr.AddNamespace(a.Value, a.Name.Substring(6));
System.Uri uri = new System.Uri(a.Value);
if (uri.Scheme != "assembly") continue;
System.Reflection.Assembly assembly = System.Reflection.Assembly.Load(uri.Host);
System.Type ty = assembly.GetType(uri.AbsolutePath.Substring(1));
if (ty == null) {
Console.Error.WriteLine("Type not found: " + uri);
return;
}
object obj = ty.GetConstructor(new Type[0]).Invoke(new Type[0]);
xsltargs.AddExtensionObject(a.Value, obj);
}
StatementSource source = Store.CreateForInput(datasource);
Store model;
if (source is Store) model = (Store)source;
else model = new MemoryStore(source);
XPathNavigator nav;
if (rootentity != null)
nav = new XPathSemWebNavigator(rootentity, model, nsmgr);
else
nav = new XPathSemWebNavigator(model, nsmgr);
t.Transform(nav, xsltargs, Console.Out, null);
}
/// <summary>
/// Exports dataset into excel format
/// </summary>
/// <param name="dsExport">The DataSet want to export</param>
/// <param name="sHeaders">The headers of DataTable</param>
/// <param name="sFields">The data fields of DataTable</param>
/// <param name="fileName">The filename of excel</param>
private void ExportWithXSLT(DataSet dsExport, string[] sHeaders, string[] sFields, string fileName)
{
try
{
//Appending Headers
response.Clear();
response.Buffer = true;
response.ContentType = "application/vnd.ms-excel";
response.ContentEncoding = System.Text.Encoding.Default;
//response.AppendHeader("content-disposition", "attachment; filename="+"测试.xls");
response.AppendHeader("content-disposition", "attachment; filename=" +fileName+".xls");
//XSLT to use for transforming this dataset
MemoryStream stream = new MemoryStream();
XmlTextWriter writer = new XmlTextWriter(stream, Encoding.Unicode);
CreateStylesheet(writer, sHeaders, sFields);
//Create the Stylesheet
writer.Flush();
stream.Seek(0, SeekOrigin.Begin);
XmlDocument xmlDoc = new XmlDataDocument(dsExport);
XslTransform xslTran = new XslTransform();
xslTran.Load(new XmlTextReader(stream), null, null);
System.IO.StringWriter sw = new StringWriter();
xslTran.Transform(xmlDoc, null, sw, null);
//Write out the content
response.Write(sw.ToString());
sw.Close();
writer.Close();
stream.Close();
response.End();
}
catch (ThreadAbortException ex)
{
string ErrMsg = ex.Message;
}
catch (Exception ex)
{
throw ex;
}
}
// Function : Export_with_XSLT_Web
// Arguments : dsExport, sHeaders, sFileds, FormatType, FileName
// Purpose : Exports dataset into CSV / Excel format
private void Export_with_XSLT_Web(DataSet dsExport, string[] sHeaders, string[] sFileds, ExportFormat FormatType, string FileName)
{
try
{
// Appending Headers
response.Clear();
response.Buffer= true;
response.ContentEncoding = Encoding.GetEncoding("GB2312");
if(FormatType == ExportFormat.CSV)
{
response.ContentType = "text/csv";
response.AppendHeader("content-disposition", "attachment; filename=" + FileName);
}
else
{
response.ContentType = "application/vnd.ms-excel";
response.AppendHeader("content-disposition", "attachment; filename=" + FileName);
}
// XSLT to use for transforming this dataset.
MemoryStream stream = new MemoryStream( );
XmlTextWriter writer = new XmlTextWriter(stream, Encoding.UTF8);
CreateStylesheet(writer, sHeaders, sFileds, FormatType);
writer.Flush( );
stream.Seek( 0, SeekOrigin.Begin);
XmlDataDocument xmlDoc = new XmlDataDocument(dsExport);
XslTransform xslTran = new XslTransform();//��ʱ����
//XslCompiledTransform xslTran = new XslCompiledTransform();
xslTran.Load(new XmlTextReader(stream), null, null);
System.IO.StringWriter sw = new System.IO.StringWriter();
xslTran.Transform(xmlDoc, null, sw, null);
//Writeout the Content
response.Write(sw.ToString());
sw.Close();
writer.Close();
stream.Close();
response.End();
}
catch(ThreadAbortException Ex)
{
string ErrMsg = Ex.Message;
}
catch(Exception Ex)
{
throw Ex;
}
}
// Function : Export_with_XSLT_Windows
// Arguments : dsExport, sHeaders, sFileds, FormatType, FileName
// Purpose : Exports dataset into CSV / Excel format
private void Export_with_XSLT_Windows(DataSet dsExport, string[] sHeaders, string[] sFileds, ExportFormat FormatType, string FileName)
{
try
{
// XSLT to use for transforming this dataset.
MemoryStream stream = new MemoryStream( );
XmlTextWriter writer = new XmlTextWriter(stream, Encoding.UTF8);
CreateStylesheet(writer, sHeaders, sFileds, FormatType);
writer.Flush( );
stream.Seek( 0, SeekOrigin.Begin);
XmlDataDocument xmlDoc = new XmlDataDocument(dsExport);
XslTransform xslTran = new XslTransform();//��ʱ����
//XslCompiledTransform xslTran = new XslCompiledTransform();
xslTran.Load(new XmlTextReader(stream), null, null);
System.IO.StringWriter sw = new System.IO.StringWriter();
xslTran.Transform(xmlDoc, null, sw, null);
//Writeout the Content
StreamWriter strwriter = new StreamWriter(FileName);
strwriter.WriteLine(sw.ToString());
strwriter.Close();
sw.Close();
writer.Close();
stream.Close();
}
catch(Exception Ex)
{
throw Ex;
}
}
public static void CheckDiff (string diffFile)
{
int suc=0, tot=0, ign=0;
XmlDocument doc = new XmlDocument ();
doc.Load (diffFile);
XmlDocument errdoc = new XmlDocument ();
errdoc.Load ("proxy-gen-error.xml");
XmlDocument result = new XmlDocument ();
XmlElement res = result.CreateElement ("test-results");
res.SetAttribute ("name", "wsdl-tests");
res.SetAttribute ("date", DateTime.Now.ToShortDateString ());
res.SetAttribute ("time", DateTime.Now.ToShortTimeString ());
result.AppendChild (res);
XmlElement ts = result.CreateElement ("test-suite");
ts.SetAttribute ("name", "wsdl");
ts.SetAttribute ("asserts", "0");
ts.SetAttribute ("time", "0");
res.AppendChild (ts);
XmlElement tsres = result.CreateElement ("results");
ts.AppendChild (tsres);
XslTransform xsl = new XslTransform ();
xsl.Load ("cormissing.xsl");
foreach (ServiceData sd in services.services)
{
if (sd.Protocols == null) continue;
foreach (string prot in sd.Protocols)
{
string ns = sd.Namespace + "." + prot;
XmlElement elem = doc.SelectSingleNode ("assemblies/assembly/namespaces/namespace[@name='" + ns + "']") as XmlElement;
if (elem == null) {
ign++;
continue;
}
if (!File.Exists (GetWsdlFile(sd))) {
Console.WriteLine ("WARNING: wsdl file not found: " + GetWsdlFile(sd));
ign++;
continue;
}
tot++;
bool extrans = elem.GetAttribute ("presence") == "extra";
if ((elem.GetAttribute ("error") != "" || elem.GetAttribute ("missing") != "" || elem.GetAttribute ("extra") != "") && !extrans)
{
XmlElement errelem = errdoc.SelectSingleNode ("/errors/error[@ns='" + ns + "']") as XmlElement;
if (errelem != null) {
WriteResult (tsres, ns, false, sd.Wsdl + "\n" + errelem.InnerText);
}
else {
StringWriter str = new StringWriter ();
xsl.Transform (elem, null, str, null);
WriteResult (tsres, ns, false, sd.Wsdl + "\n" + str.ToString ());
}
}
else
{
if (extrans) Console.WriteLine ("BONUS CLASS: " + ns);
suc++;
WriteResult (tsres, ns, true, sd.Wsdl);
}
}
}
ts.SetAttribute ("success", (suc < tot).ToString());
res.SetAttribute ("total", tot.ToString());
res.SetAttribute ("failures", (tot-suc).ToString());
res.SetAttribute ("not-run", "0");
result.Save ("WsdlTestResult.xml");
Console.WriteLine ("Compared:" + tot + " Ignored:" + ign + " Sucess:" + suc + " Fail:" + (tot - suc));
}
/// <summary>
/// Transforms the <see cref="XmlDocument"/>.
/// </summary>
/// <param name="document">The document to be transformed.</param>
/// <returns>Returns the resulting <see cref="XmlDocument"/>.</returns>
public XmlDocument Transform(XmlDocument document)
{
XslTransform xslt = new XslTransform();
XsltArgumentList args = new XsltArgumentList();
if (HttpContext.Current == null)
{
xslt.Load(System.IO.Path.Combine(basePath,this.Type) + ".xslt");
}
else
{
xslt.Load(HttpContext.Current.Server.MapPath(this.Type + ".xslt"));
foreach (string key in HttpContext.Current.Request.Params.AllKeys) {
try {
args.AddParam(key, String.Empty, HttpContext.Current.Request.Params[key]);
} catch (Exception ex) { }
}
}
MemoryStream ms = new MemoryStream();
xslt.Transform(document, args, ms);
XmlDocument output = new XmlDocument();
output.LoadXml(System.Text.Encoding.ASCII.GetString(ms.ToArray()));
return output;
}
public static void Main(string[] args) {
if (args.Length != 2)
return;
// Read in the output rules files
XmlDocument stylesheet = new XmlDocument();
XmlElement stylesheet_root = stylesheet.CreateElement("xsl:stylesheet", "http://www.w3.org/1999/XSL/Transform");
stylesheet_root.SetAttribute("version", "1.0");
stylesheet.AppendChild(stylesheet_root);
/*XmlElement outputnode = stylesheet.CreateElement("xsl:output", "http://www.w3.org/1999/XSL/Transform");
outputnode.SetAttribute("method", "text");
stylesheet_root.AppendChild(outputnode);*/
XmlElement basetemplate = stylesheet.CreateElement("xsl:template", "http://www.w3.org/1999/XSL/Transform");
basetemplate.SetAttribute("match", "*");
basetemplate.InnerXml = "[<xsl:value-of xmlns:xsl='http://www.w3.org/1999/XSL/Transform' select=\"name()\"/>:"
+ "<xsl:for-each select='*' xmlns:xsl='http://www.w3.org/1999/XSL/Transform'>"
+ "[<xsl:value-of select='name(.)'/>]"
+ "</xsl:for-each>]";
stylesheet_root.AppendChild(basetemplate);
StreamReader csgen = new StreamReader("csgen.txt");
System.Text.RegularExpressions.Regex SubstParam = new System.Text.RegularExpressions.Regex(@"@([\w\*]+)(\[[^\]]+\])?");
string csgen_line;
while ((csgen_line = csgen.ReadLine()) != null) {
if (csgen_line == "" || csgen_line[0] == '#') { continue; }
int sp = csgen_line.IndexOf(" ");
if (sp == -1) { continue; }
string rule = csgen_line.Substring(sp+1);
int priority = -1;
if (csgen_line.StartsWith("*"))
priority = 10;
if (csgen_line.StartsWith("!")) {
priority = 20;
csgen_line = csgen_line.Substring(1);
}
XmlElement template = stylesheet.CreateElement("xsl:template", "http://www.w3.org/1999/XSL/Transform");
template.SetAttribute("match", csgen_line.Substring(0, sp));
template.SetAttribute("xml:space", "preserve");
if (priority != -1)
template.SetAttribute("priority", priority.ToString());
if (rule == "none") {
template.InnerXml = "<xsl:apply-templates xmlns:xsl='http://www.w3.org/1999/XSL/Transform' select='*'/>";
} else if (rule == "text") {
template.InnerXml = "<xsl:value-of xmlns:xsl='http://www.w3.org/1999/XSL/Transform' select='@Text'/>";
} else {
rule = rule.Replace("|", "\n");
if (!rule.EndsWith("\\")) rule += "\n"; else rule = rule.Substring(0, rule.Length-1);
rule = rule.Replace("@@1", "<xsl:apply-templates xmlns:xsl='http://www.w3.org/1999/XSL/Transform' select='*[position()>1]'/>");
rule = rule.Replace("@@", "<xsl:apply-templates xmlns:xsl='http://www.w3.org/1999/XSL/Transform'/>");
foreach (System.Text.RegularExpressions.Match match in SubstParam.Matches(rule)) {
string type = match.Result("$1");
string sep = match.Result("$2");
if (sep != "") sep = sep.Substring(1, sep.Length-2);
if (type == "text") {
rule = rule.Replace(match.Value, "<xsl:value-of xmlns:xsl='http://www.w3.org/1999/XSL/Transform' select='@Text'/>");
} else {
if (char.IsDigit(type[0]))
type = "*[position()=" + type + "]";
if (sep == "")
rule = rule.Replace(match.Value, "<xsl:apply-templates xmlns:xsl='http://www.w3.org/1999/XSL/Transform' select='" + type + "'/>");
else
rule = rule.Replace(match.Value,
"<xsl:for-each xmlns:xsl='http://www.w3.org/1999/XSL/Transform' select='" + type + "'>"
+ "<xsl:if test='not(position()=1)'>" + sep + "</xsl:if>"
+ "<xsl:apply-templates select='.'/>"
+ "</xsl:for-each>");
}
}
template.InnerXml = rule;
}
stylesheet_root.AppendChild(template);
}
CSharpAST
left = GetAST(args[0]),
right = GetAST(args[1]);
StringWriter buffer = new StringWriter();
XmlTextWriter output = new XmlTextWriter(buffer);
//output.Formatting = Formatting.Indented;
StructuredDiff test = new XmlOutputStructuredDiff(output, null);
test.AddInterface(typeof(ASTNode), new ASTNodeInterface());
test.Compare(left, right);
output.Close();
XmlDocument diff = new XmlDocument();
diff.LoadXml(buffer.ToString());
XslTransform transform = new XslTransform();
transform.Load(stylesheet);
XmlReader diffcontent = transform.Transform(diff, null);
throw new Exception(diffcontent.BaseURI == null ? "null" : "not null");
XmlDocument diffdoc = new XmlDocument();
diffdoc.Load(diffcontent);
diffdoc.Normalize();
WriteChildren(diffdoc.DocumentElement, 0, ' ');
Console.WriteLine();
}
private void DoTransform(string xsl, string xml, string output)
{
try
{
#if true
/// new way
///
//Create the XslTransform and load the stylesheet.
System.Xml.Xsl.XslCompiledTransform xslt = new System.Xml.Xsl.XslCompiledTransform();
xslt.Load(xsl, System.Xml.Xsl.XsltSettings.TrustedXslt, null);
//Load the XML data file.
System.Xml.XPath.XPathDocument doc = new System.Xml.XPath.XPathDocument(xml);
//Create an XmlTextWriter to output to the console.
System.Xml.XmlTextWriter writer = new System.Xml.XmlTextWriter(output, System.Text.Encoding.UTF8);
writer.Formatting = System.Xml.Formatting.Indented;
//Transform the file.
xslt.Transform(doc, null, writer);
writer.Close();
#if false
//Create the XslTransform and load the stylesheet.
XslTransform xslt = new XslTransform();
xslt.Load(xsl);
//Load the XML data file.
XPathDocument doc = new XPathDocument(xml);
//Create an XmlTextWriter to output to the console.
XmlTextWriter writer = new XmlTextWriter(output, System.Text.Encoding.UTF8);
writer.Formatting = Formatting.Indented;
//Transform the file.
xslt.Transform(doc, null, writer, null);
writer.Close();
#endif
#else
SIL.Utils.XmlUtils.TransformFileToFile(xsl, xml, output);
#endif
}
catch(Exception ee)
{
System.Diagnostics.Debug.WriteLine(ee.Message);
}
}
private void CreateSummaryDocument()
{
XPathDocument originalXPathDocument = new XPathDocument (new FileStream (outputFile, FileMode.Open));
XslTransform summaryXslTransform = new XslTransform();
summaryXslTransform.Load(transformReader);
summaryXslTransform.Transform(originalXPathDocument,null,Console.Out);
}
private static void Generate(XmlDocument source, XslTransform transform, XsltArgumentList args, string output, XslTransform template) {
using (TextWriter textwriter = new StreamWriter(new FileStream(output, FileMode.Create))) {
XmlTextWriter writer = new XmlTextWriter(textwriter);
writer.Formatting = Formatting.Indented;
writer.Indentation = 2;
writer.IndentChar = ' ';
try {
XmlDocument intermediate = new XmlDocument();
intermediate.PreserveWhitespace = true;
intermediate.Load(transform.Transform(source, args, new ManifestResourceResolver(opts.source)));
template.Transform(intermediate, new XsltArgumentList(), new XhtmlWriter (writer), null);
} catch (Exception e) {
throw new ApplicationException("An error occured while generating " + output, e);
}
}
}
private void genExcelByXSL()
{
DataTable dt = getData();
XmlDataDocument xdd = new XmlDataDocument(dt.DataSet);
Response.ContentType = "application/vnd.ms-excel";
Response.Charset = "";
XslTransform xt = new XslTransform();
xt.Load(Server.MapPath("xml/excelTemp.xslt"));
xt.Transform(xdd, null, Response.OutputStream);
Response.End();
}
