/// <summary>
/// Transforms given <see cref="XmlInput"/> into <see cref="XmlReader"/>.
/// </summary>
/// <param name="input">Default input XML document</param>
/// <param name="arguments">An <see cref="XsltArgumentList"/> containing the namespace-qualified
/// arguments used as input to the transform. This value can be a null reference (Nothing in Visual Basic).</param>
public XmlReader Transform(XmlInput input, XsltArgumentList arguments)
{
XslReader r = new XslReader(this.compiledTransform);
r.StartTransform(input, AddExsltExtensionObjectsSync(arguments));
return(r);
}
/// <summary>
/// Transforms given <see cref="XmlInput"/> into <see cref="XmlReader"/>.
/// </summary>
/// <param name="input">Default input XML document</param>
/// <param name="arguments">An <see cref="XsltArgumentList"/> containing the namespace-qualified
/// arguments used as input to the transform. This value can be a null reference (Nothing in Visual Basic).</param>
/// <param name="multiThread">Defines in which mode (multithreaded or singlethreaded)
/// this instance of XslReader will operate</param>
/// <param name="initialBufferSize">Initial buffer size (number of nodes, not bytes)</param>
public XmlReader Transform(XmlInput input, XsltArgumentList arguments, bool multiThread, int initialBufferSize)
{
XslReader r = new XslReader(this.compiledTransform, multiThread, initialBufferSize);
r.StartTransform(input, AddExsltExtensionObjectsSync(arguments));
return(r);
}
private void TransformToWriter(XmlInput defaultDocument, XsltArgumentList xsltArgs, XmlWriter xmlWriter)
{
XsltArgumentList args = AddExsltExtensionObjects(xsltArgs);
XmlReader xmlReader = defaultDocument.source as XmlReader;
if (xmlReader != null)
{
this.compiledTransform.Transform(xmlReader, args, xmlWriter, defaultDocument.resolver);
return;
}
IXPathNavigable nav = defaultDocument.source as IXPathNavigable;
if (nav != null)
{
if (defaultDocument.resolver is DefaultXmlResolver)
{
this.compiledTransform.Transform(nav, args, xmlWriter);
}
else
{
TransformIXPathNavigable(nav, args, xmlWriter, defaultDocument.resolver);
}
return;
}
string str = defaultDocument.source as string;
if (str != null)
{
using (XmlReader reader = XmlReader.Create(str, GetReaderSettings(defaultDocument)))
{
this.compiledTransform.Transform(reader, args, xmlWriter, defaultDocument.resolver);
}
return;
}
Stream strm = defaultDocument.source as Stream;
if (strm != null)
{
using (XmlReader reader = XmlReader.Create(strm, GetReaderSettings(defaultDocument)))
{
this.compiledTransform.Transform(reader, args, xmlWriter, defaultDocument.resolver);
}
return;
}
TextReader txtReader = defaultDocument.source as TextReader;
if (txtReader != null)
{
using (XmlReader reader = XmlReader.Create(txtReader, GetReaderSettings(defaultDocument)))
{
this.compiledTransform.Transform(reader, args, xmlWriter, defaultDocument.resolver);
}
return;
}
throw new Exception("Unexpected XmlInput");
}
/// <summary>
/// Gets XML Reader settings (customized if there is custom XML resolver)
/// </summary>
/// <returns></returns>
protected XmlReaderSettings GetReaderSettings(XmlInput defaultDocument)
{
if (defaultDocument.resolver is DefaultXmlResolver)
{
return(DefaultReaderSettings);
}
else
{
XmlReaderSettings settings = DefaultReaderSettings.Clone();
settings.XmlResolver = defaultDocument.resolver;
return(settings);
}
}
public static string GetXmlString(string stylesheet, string xmlstring, List<XsltExtensionParam> listExtensionParam,
bool enableDocumentFunction, bool enableScript)
{
MvpXslTransform xslt = new MvpXslTransform();
string text = string.Empty;
try {
using (XmlReader strm = XmlReader.Create(new MemoryStream(ASCIIEncoding.Default.GetBytes(stylesheet)))) {
if (enableDocumentFunction && enableScript) {
XsltSettings xslSettings = new XsltSettings(enableDocumentFunction, enableScript);
XmlResolver xmlResolver = new XmlUrlResolver();
xslt.Load(strm, xslSettings, xmlResolver);
} else if (enableDocumentFunction && !enableScript) {
XsltSettings xslSettings = new XsltSettings(enableDocumentFunction, false);
XmlResolver xmlResolver = new XmlUrlResolver();
xslt.Load(strm, xslSettings, xmlResolver);
} else {
xslt.Load(strm);
}
}
using (TextReader stringReader = new StringReader(xmlstring)) {
XPathDocument mydata = new XPathDocument(stringReader);
XmlInput a = new XmlInput(mydata);
using (TextWriter txtWriter = new StringWriter()) {
XsltArgumentList b = new XsltArgumentList();
foreach (XsltExtensionParam oep in listExtensionParam) {
b.AddExtensionObject(oep.Namespace, oep.Object);
}
xslt.Transform(a, b, new XmlOutput(txtWriter));
text = txtWriter.ToString();
}
}
} catch (Exception ex) {
}
return text;
}
public void TestXPointerIndentationBug()
{
XmlUrlResolver resolver = new XmlUrlResolver();
resolver.Credentials = CredentialCache.DefaultCredentials;
XsltSettings xsltSettings = new XsltSettings();
xsltSettings.EnableDocumentFunction = true;
XmlReaderSettings settings = new XmlReaderSettings();
settings.ProhibitDtd = false;
XmlReader reader = XmlReader.Create("../../XInclude/tests/Transform.xsl", settings);
XIncludingReader xInputReader = new XIncludingReader("../../XInclude/tests/FileA.xml");
try
{
MvpXslTransform processor = new MvpXslTransform(false);
processor.Load(reader, xsltSettings, resolver);
//xInputReader.XmlResolver = new XMLBase();
XmlDocument xInputDoc = new XmlDocument();
xInputDoc.Load(xInputReader);
XmlInput xInput = new XmlInput(xInputDoc);
StringWriter stringW = new StringWriter();
XmlOutput xOutput = new XmlOutput(stringW);
processor.Transform(xInput, null, xOutput);
processor.TemporaryFiles.Delete();
Assert.AreEqual("<?xml version=\"1.0\" encoding=\"utf-16\"?>NodeA Content", stringW.ToString());
}
finally
{
reader.Close();
xInputReader.Close();
}
}
public void TestStringInput()
{
MvpXslTransform xslt = GetMvpXslTransform();
XmlInput input = new XmlInput("../../Common/northwind.xml");
MemoryStream ms = new MemoryStream();
xslt.Transform(input, Arguments, new XmlOutput(ms));
CompareResults(standardResult, ms.ToArray());
}
public void ExsltTest()
{
MvpXslTransform xslt = new MvpXslTransform();
xslt.Load("../../Common/MvpXslTransformTests/exslt-test.xslt");
XmlInput input = new XmlInput("../../Common/MvpXslTransformTests/test.xml");
MemoryStream ms = new MemoryStream();
xslt.Transform(input, Arguments, new XmlOutput(ms));
string expected = "<out>3</out>";
CompareResults(Encoding.ASCII.GetBytes(expected), ms.ToArray());
}
public void ResolverTestStreamInput()
{
MvpXslTransform xslt = GetMvpXslTransform2();
using (FileStream fs = File.OpenRead("../../Common/MvpXslTransformTests/test.xml"))
{
XmlInput input = new XmlInput(fs, new MyXmlResolver());
MemoryStream ms = new MemoryStream();
xslt.Transform(input, Arguments, new XmlOutput(ms));
CompareResults(resolverTestStandardResult, ms.ToArray());
}
}
/// <summary>
/// Transforms to XmlWriter.
/// </summary>
protected void TransformToWriter(XmlInput defaultDocument, XsltArgumentList xsltArgs, XmlWriter targetWriter)
{
XmlWriter xmlWriter;
if (this.supportCharacterMaps && this.characterMap != null && this.characterMap.Count > 0)
{
xmlWriter = new CharacterMappingXmlWriter(targetWriter, this.characterMap);
}
else
{
xmlWriter = targetWriter;
}
if (this.enforceXHTMLOutput)
{
xmlWriter = new XhtmlWriter(xmlWriter);
}
XsltArgumentList args = AddExsltExtensionObjectsSync(xsltArgs);
XmlReader xmlReader = defaultDocument.source as XmlReader;
if (xmlReader != null)
{
this.compiledTransform.Transform(xmlReader, args, xmlWriter, defaultDocument.resolver);
return;
}
IXPathNavigable nav = defaultDocument.source as IXPathNavigable;
if (nav != null)
{
if (defaultDocument.resolver is DefaultXmlResolver)
{
this.compiledTransform.Transform(nav, args, xmlWriter);
}
else
{
TransformIXPathNavigable(nav, args, xmlWriter, defaultDocument.resolver);
}
return;
}
string str = defaultDocument.source as string;
if (str != null)
{
using (XmlReader reader = XmlReader.Create(str, GetReaderSettings(defaultDocument)))
{
this.compiledTransform.Transform(reader, args, xmlWriter, defaultDocument.resolver);
}
return;
}
Stream strm = defaultDocument.source as Stream;
if (strm != null)
{
using (XmlReader reader = XmlReader.Create(strm, GetReaderSettings(defaultDocument)))
{
this.compiledTransform.Transform(reader, args, xmlWriter, defaultDocument.resolver);
}
return;
}
TextReader txtReader = defaultDocument.source as TextReader;
if (txtReader != null)
{
using (XmlReader reader = XmlReader.Create(txtReader, GetReaderSettings(defaultDocument)))
{
this.compiledTransform.Transform(reader, args, xmlWriter, defaultDocument.resolver);
}
return;
}
throw new Exception("Unexpected XmlInput");
}
/// <summary>
/// Gets XML Reader settings (customized if there is custom XML resolver)
/// </summary>
/// <returns></returns>
protected XmlReaderSettings GetReaderSettings(XmlInput defaultDocument)
{
if (defaultDocument.resolver is DefaultXmlResolver)
{
return DefaultReaderSettings;
}
else
{
XmlReaderSettings settings = DefaultReaderSettings.Clone();
settings.XmlResolver = defaultDocument.resolver;
return settings;
}
}
/// <summary>
/// Transforms given <see cref="XmlInput"/> into <see cref="XmlReader"/>.
/// </summary>
/// <param name="input">Default input XML document</param>
/// <param name="arguments">An <see cref="XsltArgumentList"/> containing the namespace-qualified
/// arguments used as input to the transform. This value can be a null reference (Nothing in Visual Basic).</param>
/// <param name="multiThread">Defines in which mode (multithreaded or singlethreaded)
/// this instance of XslReader will operate</param>
/// <param name="initialBufferSize">Initial buffer size (number of nodes, not bytes)</param>
public XmlReader Transform(XmlInput input, XsltArgumentList arguments, bool multiThread, int initialBufferSize)
{
XslReader r = new XslReader(this.compiledTransform, multiThread, initialBufferSize);
r.StartTransform(input, AddExsltExtensionObjectsSync(arguments));
return r;
}
/// <summary>
/// Transforms given <see cref="XmlInput"/> into <see cref="XmlReader"/>.
/// </summary>
/// <param name="input">Default input XML document</param>
/// <param name="arguments">An <see cref="XsltArgumentList"/> containing the namespace-qualified
/// arguments used as input to the transform. This value can be a null reference (Nothing in Visual Basic).</param>
public XmlReader Transform(XmlInput input, XsltArgumentList arguments)
{
XslReader r = new XslReader(this.compiledTransform);
r.StartTransform(input, AddExsltExtensionObjectsSync(arguments));
return r;
}
/// <summary>
/// Transforms given <see cref="XmlInput"/> into <see cref="XmlOutput"/>.
/// The <see cref="XsltArgumentList"/> provides additional runtime arguments.
/// </summary>
/// <param name="input">Default input XML document.</param>
/// <param name="arguments">An <see cref="XsltArgumentList"/> containing the namespace-qualified
/// arguments used as input to the transform. This value can be a null reference (Nothing in Visual Basic).</param>
/// <param name="output">Represents the transformation's output.</param>
/// <returns>Transformation output.</returns>
public XmlOutput Transform(XmlInput input, XsltArgumentList arguments, XmlOutput output)
{
if (input == null) throw new ArgumentNullException("defaltDocument");
XmlWriter xmlWriter = output.destination as XmlWriter;
bool closeWriter = false;
if (xmlWriter == null)
{
closeWriter = true;
while (true)
{
TextWriter txtWriter = output.destination as TextWriter;
if (txtWriter != null)
{
if (multiOutput)
{
MultiXmlTextWriter mw = new MultiXmlTextWriter(txtWriter, output.XmlResolver);
if (this.compiledTransform.OutputSettings.Indent)
{
mw.Formatting = Formatting.Indented;
}
xmlWriter = mw;
}
else
{
xmlWriter = XmlWriter.Create(txtWriter, this.compiledTransform.OutputSettings);
}
break;
}
Stream strm = output.destination as Stream;
if (strm != null)
{
if (multiOutput)
{
MultiXmlTextWriter mw = new MultiXmlTextWriter(strm, this.compiledTransform.OutputSettings.Encoding, output.XmlResolver);
if (this.compiledTransform.OutputSettings.Indent)
{
mw.Formatting = Formatting.Indented;
}
xmlWriter = mw;
}
else
{
xmlWriter = XmlWriter.Create(strm, this.compiledTransform.OutputSettings);
}
break;
}
String str = output.destination as String;
if (str != null)
{
if (multiOutput)
{
MultiXmlTextWriter mw = new MultiXmlTextWriter(str, this.compiledTransform.OutputSettings.Encoding);
if (this.compiledTransform.OutputSettings.Indent)
{
mw.Formatting = Formatting.Indented;
}
xmlWriter = mw;
}
else
{
XmlWriterSettings outputSettings = this.compiledTransform.OutputSettings.Clone();
outputSettings.CloseOutput = true;
// BugBug: We should read doc before creating output file in case they are the same
xmlWriter = XmlWriter.Create(str, outputSettings);
}
break;
}
throw new Exception("Unexpected XmlOutput");
}
}
try
{
TransformToWriter(input, arguments, xmlWriter);
}
finally
{
if (closeWriter)
{
xmlWriter.Close();
}
}
return output;
}
public override void xslTransformer(XPathNavigator xNav, XsltArgumentList xArgs)
{
XsltSettings settings = new XsltSettings(true, true);
XmlUrlResolver r = new XmlUrlResolver();
r.Credentials = System.Net.CredentialCache.DefaultCredentials;
MvpXslTransform xslObj = new MvpXslTransform();
xslObj.SupportCharacterMaps = false; // causes error reading
var readersettings = new XmlReaderSettings();
using (XmlReader xslreader = XmlReader.Create(classXSLObjectSource, readersettings))
{
xslObj.Load(xslreader, settings, r);
XmlInput xm = new XmlInput(xNav);
XmlOutput xo;
try
{
if (!(clsFileIO == null))
{
xo = new XmlOutput(clsFileIO);
xslObj.Transform(xm, xArgs, xo);
clsTEXTResult = "FILE SAVED";
}
else if (!(clsHTTPResponse == null))
{
xo = new XmlOutput(clsHTTPResponse.OutputStream);
xslObj.Transform(xm, xArgs, xo);
clsTEXTResult = "OUTPUT STREAMED TO HTTP RESPONSE";
}
else if (!(clsXMLObjectReturn == null))
{
using (StringWriter sWrit = new StringWriter())
{
xo = new XmlOutput(sWrit);
xslObj.Transform(xm, xArgs, xo);
clsXMLObjectReturn.LoadXml(sWrit.ToString());
}
}
else
{
using (StringWriter sWrit = new StringWriter())
{
xo = new XmlOutput(sWrit);
xslObj.Transform(xm, xArgs, xo);
// default - results to text
clsTEXTResult = sWrit.ToString();
}
}
}
catch (Exception unhandled)
{
throw unhandled;
}
finally
{
xslObj = null;
xm = null;
xo = null;
}
}
}
public void TestIXPathNavigableInput2()
{
MvpXslTransform xslt = GetMvpXslTransform();
XmlInput input = new XmlInput(new XPathDocument("../../Common/northwind.xml", XmlSpace.Preserve));
MemoryStream ms = new MemoryStream();
XmlReader r = xslt.Transform(input, Arguments);
XmlWriter w = XmlWriter.Create(ms);
w.WriteNode(r, false);
w.Close();
CompareResults(standardResult, ms.ToArray());
}
public void TestXmlWriterOutput()
{
MvpXslTransform xslt = GetMvpXslTransform();
XmlInput input = new XmlInput("../../Common/northwind.xml");
XmlWriter w = XmlWriter.Create("../../Common/MvpXslTransformTests/out.xml");
xslt.Transform(input, Arguments, new XmlOutput(w));
w.Close();
using (FileStream fs = File.OpenRead("../../Common/MvpXslTransformTests/out.xml"))
{
byte[] bytes = new byte[fs.Length];
fs.Read(bytes, 0, bytes.Length);
CompareResults(standardResult, bytes);
}
}
public void TestTextReaderInput2()
{
MvpXslTransform xslt = GetMvpXslTransform();
XmlInput input = new XmlInput(new StreamReader("../../northwind.xml", Encoding.GetEncoding("windows-1252")));
MemoryStream ms = new MemoryStream();
XmlReader r = xslt.Transform(input, Arguments);
XmlWriter w = XmlWriter.Create(ms);
w.WriteNode(r, false);
w.Close();
CompareResults(standardResult, ms.ToArray());
}
public void ResolverTestIXPathNavigableInput()
{
MvpXslTransform xslt = GetMvpXslTransform2();
XmlInput input = new XmlInput(new XPathDocument("../../Common/MvpXslTransformTests/test.xml"), new MyXmlResolver());
MemoryStream ms = new MemoryStream();
xslt.Transform(input, Arguments, new XmlOutput(ms));
CompareResults(resolverTestStandardResult, ms.ToArray());
}
public void TestStreamOutput()
{
MvpXslTransform xslt = GetMvpXslTransform();
XmlInput input = new XmlInput("../../northwind.xml");
using (FileStream outStrm = File.OpenWrite("../../MvpXslTransformTests/out.xml")) {
xslt.Transform(input, Arguments, new XmlOutput(outStrm));
}
using (FileStream fs = File.OpenRead("../../MvpXslTransformTests/out.xml"))
{
byte[] bytes = new byte[fs.Length];
fs.Read(bytes, 0, bytes.Length);
CompareResults(standardResult, bytes);
}
}
public void NoExsltTest()
{
MvpXslTransform xslt = new MvpXslTransform();
xslt.Load("../../Common/MvpXslTransformTests/exslt-test.xslt");
XmlInput input = new XmlInput("../../Common/MvpXslTransformTests/test.xml");
MemoryStream ms = new MemoryStream();
xslt.SupportedFunctions = Mvp.Xml.Exslt.ExsltFunctionNamespace.None;
try
{
xslt.Transform(input, Arguments, new XmlOutput(ms));
}
catch (XsltException) { return; }
Assert.Fail("Shoudn't be here.");
}
public void ResolverTestXmlReaderInput()
{
MvpXslTransform xslt = GetMvpXslTransform2();
XmlInput input = new XmlInput(XmlReader.Create("../../MvpXslTransformTests/test.xml"), new MyXmlResolver());
MemoryStream ms = new MemoryStream();
xslt.Transform(input, Arguments, new XmlOutput(ms));
CompareResults(resolverTestStandardResult, ms.ToArray());
}
/// <summary>
/// Starts XSL transformation of given <see cref="XmlInput"/> object with
/// specified <see cref="XsltArgumentList"/>. After this method returns
/// you can read the transformation output out of XslReader object via
/// standard <see cref="XmlReader"/> methods such as Read() or MoveXXX().
/// </summary>
/// <remarks>If the <c>StartTransform()</c> method is called when previous
/// transformation isn't over yet, it will be aborted, buffer cleaned and
/// XslReader object reset to an initial state automatically.</remarks>
/// <param name="input">An input XML to be transformed</param>
/// <param name="args">A collection of global parameter values and
/// extension objects.</param>
/// <returns></returns>
public XmlReader StartTransform(XmlInput input, XsltArgumentList args)
{
this.defaulDocument = input;
this.args = args;
Start();
return this;
}
public void TestStreamInput()
{
MvpXslTransform xslt = GetMvpXslTransform();
using (FileStream fs = File.OpenRead("../../Common/northwind.xml"))
{
XmlInput input = new XmlInput(fs);
MemoryStream ms = new MemoryStream();
xslt.Transform(input, Arguments, new XmlOutput(ms));
CompareResults(standardResult, ms.ToArray());
}
}
/// <summary>
/// Transforms given <see cref="XmlInput"/> into <see cref="XmlOutput"/>.
/// The <see cref="XsltArgumentList"/> provides additional runtime arguments.
/// </summary>
/// <param name="input">Default input XML document.</param>
/// <param name="arguments">An <see cref="XsltArgumentList"/> containing the namespace-qualified
/// arguments used as input to the transform. This value can be a null reference (Nothing in Visual Basic).</param>
/// <param name="output">Represents the transformation's output.</param>
/// <returns>Transformation output.</returns>
public XmlOutput Transform(XmlInput input, XsltArgumentList arguments, XmlOutput output)
{
if (input == null)
{
throw new ArgumentNullException("defaltDocument");
}
XmlWriter xmlWriter = output.destination as XmlWriter;
bool closeWriter = false;
if (xmlWriter == null)
{
closeWriter = true;
while (true)
{
TextWriter txtWriter = output.destination as TextWriter;
if (txtWriter != null)
{
if (multiOutput)
{
MultiXmlTextWriter mw = new MultiXmlTextWriter(txtWriter, output.XmlResolver);
if (this.compiledTransform.OutputSettings.Indent)
{
mw.Formatting = Formatting.Indented;
}
xmlWriter = mw;
}
else
{
xmlWriter = XmlWriter.Create(txtWriter, this.compiledTransform.OutputSettings);
}
break;
}
Stream strm = output.destination as Stream;
if (strm != null)
{
if (multiOutput)
{
MultiXmlTextWriter mw = new MultiXmlTextWriter(strm, this.compiledTransform.OutputSettings.Encoding, output.XmlResolver);
if (this.compiledTransform.OutputSettings.Indent)
{
mw.Formatting = Formatting.Indented;
}
xmlWriter = mw;
}
else
{
xmlWriter = XmlWriter.Create(strm, this.compiledTransform.OutputSettings);
}
break;
}
String str = output.destination as String;
if (str != null)
{
if (multiOutput)
{
MultiXmlTextWriter mw = new MultiXmlTextWriter(str, this.compiledTransform.OutputSettings.Encoding);
if (this.compiledTransform.OutputSettings.Indent)
{
mw.Formatting = Formatting.Indented;
}
xmlWriter = mw;
}
else
{
XmlWriterSettings outputSettings = this.compiledTransform.OutputSettings.Clone();
outputSettings.CloseOutput = true;
// BugBug: We should read doc before creating output file in case they are the same
xmlWriter = XmlWriter.Create(str, outputSettings);
}
break;
}
throw new Exception("Unexpected XmlOutput");
}
}
try
{
TransformToWriter(input, arguments, xmlWriter);
}
finally
{
if (closeWriter)
{
xmlWriter.Close();
}
}
return(output);
}
public void TestTextReaderInput()
{
MvpXslTransform xslt = GetMvpXslTransform();
XmlInput input = new XmlInput(new StreamReader("../../Common/northwind.xml", Encoding.GetEncoding("windows-1252")));
MemoryStream ms = new MemoryStream();
xslt.Transform(input, Arguments, new XmlOutput(ms));
CompareResults(standardResult, ms.ToArray());
}
public void TestIXPathNavigableInput()
{
MvpXslTransform xslt = GetMvpXslTransform();
XmlInput input = new XmlInput(new XPathDocument("../../Common/northwind.xml", XmlSpace.Preserve));
MemoryStream ms = new MemoryStream();
xslt.Transform(input, Arguments, new XmlOutput(ms));
CompareResults(standardResult, ms.ToArray());
}
public void TestXmlReaderInput2()
{
MvpXslTransform xslt = GetMvpXslTransform();
XmlInput input = new XmlInput(XmlReader.Create("../../Common/northwind.xml"));
MemoryStream ms = new MemoryStream();
XmlReader r = xslt.Transform(input, Arguments);
XmlWriter w = XmlWriter.Create(ms);
w.WriteNode(r, false);
w.Close();
CompareResults(standardResult, ms.ToArray());
}
/// <summary>
/// Transforms to XmlWriter.
/// </summary>
protected void TransformToWriter(XmlInput defaultDocument, XsltArgumentList xsltArgs, XmlWriter targetWriter)
{
XmlWriter xmlWriter;
if (this.supportCharacterMaps && this.characterMap != null && this.characterMap.Count > 0)
{
xmlWriter = new CharacterMappingXmlWriter(targetWriter, this.characterMap);
}
else
{
xmlWriter = targetWriter;
}
if (this.enforceXHTMLOutput)
{
xmlWriter = new XhtmlWriter(xmlWriter);
}
XsltArgumentList args = AddExsltExtensionObjectsSync(xsltArgs);
XmlReader xmlReader = defaultDocument.source as XmlReader;
if (xmlReader != null)
{
this.compiledTransform.Transform(xmlReader, args, xmlWriter, defaultDocument.resolver);
return;
}
IXPathNavigable nav = defaultDocument.source as IXPathNavigable;
if (nav != null)
{
if (defaultDocument.resolver is DefaultXmlResolver)
{
this.compiledTransform.Transform(nav, args, xmlWriter);
}
else
{
TransformIXPathNavigable(nav, args, xmlWriter, defaultDocument.resolver);
}
return;
}
string str = defaultDocument.source as string;
if (str != null)
{
using (XmlReader reader = XmlReader.Create(str, GetReaderSettings(defaultDocument)))
{
this.compiledTransform.Transform(reader, args, xmlWriter, defaultDocument.resolver);
}
return;
}
Stream strm = defaultDocument.source as Stream;
if (strm != null)
{
using (XmlReader reader = XmlReader.Create(strm, GetReaderSettings(defaultDocument)))
{
this.compiledTransform.Transform(reader, args, xmlWriter, defaultDocument.resolver);
}
return;
}
TextReader txtReader = defaultDocument.source as TextReader;
if (txtReader != null)
{
using (XmlReader reader = XmlReader.Create(txtReader, GetReaderSettings(defaultDocument)))
{
this.compiledTransform.Transform(reader, args, xmlWriter, defaultDocument.resolver);
}
return;
}
throw new Exception("Unexpected XmlInput");
}
private void TransformToWriter(XmlInput defaultDocument, XsltArgumentList xsltArgs, XmlWriter xmlWriter)
{
XsltArgumentList args = AddExsltExtensionObjects(xsltArgs);
XmlReader xmlReader = defaultDocument.source as XmlReader;
if (xmlReader != null)
{
this.compiledTransform.Transform(xmlReader, args, xmlWriter, defaultDocument.resolver);
return;
}
IXPathNavigable nav = defaultDocument.source as IXPathNavigable;
if (nav != null)
{
if (defaultDocument.resolver is DefaultXmlResolver)
{
this.compiledTransform.Transform(nav, args, xmlWriter);
}
else
{
TransformIXPathNavigable(nav, args, xmlWriter, defaultDocument.resolver);
}
return;
}
string str = defaultDocument.source as string;
if (str != null)
{
using (XmlReader reader = XmlReader.Create(str, GetReaderSettings(defaultDocument)))
{
this.compiledTransform.Transform(reader, args, xmlWriter, defaultDocument.resolver);
}
return;
}
Stream strm = defaultDocument.source as Stream;
if (strm != null)
{
using (XmlReader reader = XmlReader.Create(strm, GetReaderSettings(defaultDocument)))
{
this.compiledTransform.Transform(reader, args, xmlWriter, defaultDocument.resolver);
}
return;
}
TextReader txtReader = defaultDocument.source as TextReader;
if (txtReader != null)
{
using (XmlReader reader = XmlReader.Create(txtReader, GetReaderSettings(defaultDocument)))
{
this.compiledTransform.Transform(reader, args, xmlWriter, defaultDocument.resolver);
}
return;
}
throw new Exception("Unexpected XmlInput");
}
