示例#1
0
        /// <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);
        }
示例#2
0
        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();
            }
        }
示例#3
0
        /// <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;
        }
示例#4
0
        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;
                }
            }
        }
示例#5
0
        /// <summary>
        /// Actual transformation and error handling.
        /// </summary>    
        private void TransformImpl(XmlReader srcReader, MvpXslTransform xslt, XmlResolver resolver, XmlOutput results)
        {
            xslt.MultiOutput = options.MultiOutput;
            try
            {
                xslt.Transform(new XmlInput(srcReader, resolver), options.XslArgList, results);
            }
            catch (XmlException xe)
            {
                string uri = options.LoadSourceFromStdin ? NXsltStrings.FromStdin : xe.SourceUri;
                throw new NXsltException(NXsltStrings.ErrorParsingDoc, uri, Reporter.GetFullMessage(xe));
            }
            catch (XmlSchemaValidationException ve)
            {
                string uri = options.LoadSourceFromStdin ? NXsltStrings.FromStdin : srcReader.BaseURI;
                throw new NXsltException(NXsltStrings.ErrorParsingDoc, uri, Reporter.GetFullMessage(ve));
            }
            catch (Exception e)
            {
                throw new NXsltException(NXsltStrings.ErrorTransform, Reporter.GetFullMessage(e));
            }

        }
示例#6
0
 /// <summary>
 /// Performs XSL Transformation.
 /// </summary>
 private void Transform(XmlReader srcReader, MvpXslTransform xslt, XmlResolver resolver)
 {
     Stopwatch transformTimer = null;
     if (options.ShowTiming)
     {
         transformTimer = new Stopwatch();
         transformTimer.Start();
     }
     if (options.OutFile != null)
     {
         //Transform to a file
         FileStream fs;
         try
         {
             fs = File.Open(options.OutFile, FileMode.Create);
         }
         catch
         {
             throw new NXsltException(NXsltStrings.ErrorCreatingFile, options.OutFile);
         }
         try
         {
             XmlOutput results = new XmlOutput(fs);
             results.XmlResolver = new OutputResolver(Path.GetDirectoryName(options.OutFile));
             TransformImpl(srcReader, xslt, resolver, results);
         }
         finally
         {
             fs.Close();
         }
     }
     else
     {
         //Transform to Console
         XmlOutput results = new XmlOutput(Console.Out);
         results.XmlResolver = new OutputResolver(Directory.GetCurrentDirectory());
         TransformImpl(srcReader, xslt, resolver, results);
     }
     //Save transfomation time
     if (options.ShowTiming)
     {
         transformTimer.Stop();
         timings.XsltExecutionTime = transformTimer.ElapsedMilliseconds;
     }
 }