XSL.cs

using System;
using System.Reflection;
using System.IO;
using System.Text;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Xsl;
 
namespace Waher.Content.Xsl
{
    public static class XSL
    {
        public static XmlSchema LoadSchema(string ResourceName)
        {
            return LoadSchema(ResourceName, Resources.GetAssembly(ResourceName));
        }
 
        public static XmlSchema LoadSchema(string ResourceName, Assembly Assembly)
        {
            using (Stream f = Assembly.GetManifestResourceStream(ResourceName))
            {
                if (f is null)
                    throw new ArgumentException("Resource not found: " + ResourceName, nameof(ResourceName));
 
                return LoadSchema(f, ResourceName);
            }
        }
 
        public static XmlSchema LoadSchema(Stream Input, string ResourceName)
        {
            XmlValidator Validator = new XmlValidator(ResourceName);
            XmlSchema Result = XmlSchema.Read(Input, Validator.ValidationCallback);
 
            Validator.AssertNoError();
 
            return Result;
        }
 
        public static XslCompiledTransform LoadTransform(string ResourceName)
        {
            return LoadTransform(ResourceName, Resources.GetAssembly(ResourceName));
        }
 
        public static XslCompiledTransform LoadTransform(string ResourceName, Assembly Assembly)
        {
            using (Stream f = Assembly.GetManifestResourceStream(ResourceName))
            {
                if (f is null)
                    throw new ArgumentException("Resource not found: " + ResourceName, nameof(ResourceName));
 
                return LoadTransform(f);
            }
        }
 
        public static XslCompiledTransform LoadTransform(Stream Input)
        {
            using (XmlReader r = XmlReader.Create(Input))
            {
                XslCompiledTransform Xslt = new XslCompiledTransform();
                Xslt.Load(r);
 
                return Xslt;
            }
        }
 
        #region Validation
 
        public static void Validate(string ObjectID, XmlDocument Xml, params XmlSchema[] Schemas)
        {
            Validate(ObjectID, Xml, string.Empty, string.Empty, Schemas);
        }
 
        public static void Validate(string ObjectID, XmlDocument Xml, string ExpectedRootElement, string ExpectedRootElementNamespace,
            params XmlSchema[] Schemas)
        {
            if (!string.IsNullOrEmpty(ExpectedRootElement) &&
                (Xml.DocumentElement is null ||
                Xml.DocumentElement.LocalName != ExpectedRootElement ||
                Xml.DocumentElement.NamespaceURI != ExpectedRootElementNamespace))
            {
                throw new XmlSchemaException("Expected root element is " + ExpectedRootElement + " (" + ExpectedRootElementNamespace + ")");
            }
 
            foreach (XmlSchema Schema in Schemas)
                Xml.Schemas.Add(Schema);
 
            XmlValidator Validator = new XmlValidator(ObjectID);
            Xml.Validate(Validator.ValidationCallback);
 
            Validator.AssertNoError();
        }
 
        #endregion
 
        #region Transformation
 
        public static string Transform(string XML, XslCompiledTransform Transform)
        {
            StringBuilder Output = new StringBuilder();
            TextWriter OutputText = new StringWriter(Output);
            TextReader InputText = new StringReader(XML);
            XmlReader XmlReader = XmlReader.Create(InputText);
            XmlWriterSettings Settings = Content.Xml.XML.WriterSettings(false, true);
            Settings.ConformanceLevel = ConformanceLevel.Auto;
 
            XmlWriter XmlWriter = XmlWriter.Create(OutputText, Settings);
 
            try
            {
                Transform.Transform(XmlReader, XmlWriter);
            }
            finally
            {
                XmlWriter.Flush();
                OutputText.Flush();
 
                XmlReader.Close();
                InputText.Dispose();
 
                XmlWriter.Close();
                OutputText.Dispose();
            }
 
            return Output.ToString();
        }
 
        #endregion
 
    }
}