private void Init() { try { string basepath = System.Reflection.Assembly.GetExecutingAssembly().CodeBase.Replace("file:///", "").Replace("/", @"\"); basepath = System.IO.Path.GetDirectoryName(basepath) + @"\"; GameCatalogSerializer gcs = new GameCatalogSerializer(); XmlDocument doc = gcs.Serialize(games); System.Xml.XPath.XPathNavigator nav = doc.CreateNavigator(); System.Xml.Xsl.XslTransform xt = new System.Xml.Xsl.XslTransform(); System.Xml.XmlResolver res = new System.Xml.XmlUrlResolver(); System.IO.StringWriter writer = new System.IO.StringWriter(); System.Xml.Xsl.XsltArgumentList args = new System.Xml.Xsl.XsltArgumentList(); System.Xml.XmlNameTable xnt = new System.Xml.NameTable(); System.Xml.XmlReader xslt = new System.Xml.XmlTextReader(new System.IO.StreamReader(basepath + "GameList.xslt"), xnt); xt.Load(xslt, res, new System.Security.Policy.Evidence()); xt.Transform(nav, args, writer, res); string html = writer.ToString(); WriteHTML(html); } catch (Exception ex) { string error = "There was an error generating HTML"; Exception xe = ex; while (xe != null) { error += "<p><b>" + xe.Message + "</b><br><pre>" + xe.StackTrace + "</pre></p>\r\n"; } WriteHTML(error); } }
public void BuildNavigator(string modelFilePath) { XmlResolver resolver = new XmlUrlResolver(); resolver.Credentials = CredentialCache.DefaultCredentials; XmlTextReader tr = new XmlTextReader(modelFilePath); XslCompiledTransform transform = new XslCompiledTransform(); transform.Load(this.stylesheetFilesPath + Path.DirectorySeparatorChar + "ModelTree.xsl",null,resolver); XmlTextWriter tw = new XmlTextWriter(this.htmlFilesPath + Path.DirectorySeparatorChar + "ModelTree.htm", Encoding.UTF8); XsltArgumentList al = new XsltArgumentList(); al.AddParam("modelBrowser","",this.localizer.GetValue("Globals","ModelBrowser")); al.AddParam("glossary","",this.localizer.GetValue("Globals","Glossary")); al.AddParam("stakeholders", "", this.localizer.GetValue("Globals", "Stakeholders")); transform.Transform(tr,al,tw,null); tw.Close(); tr.Close(); tr = new XmlTextReader(modelFilePath); transform.Load(this.stylesheetFilesPath + Path.DirectorySeparatorChar + "HomePage.xsl",null,resolver); tw = new XmlTextWriter(this.htmlFilesPath + Path.DirectorySeparatorChar + "main.htm",Encoding.UTF8); al = new XsltArgumentList(); AssemblyName an = this.GetType().Assembly.GetName(); al.AddParam("version","",an.Version.ToString(3)); al.AddParam("model", "", this.localizer.GetValue("Globals", "Model")); al.AddParam("author", "", this.localizer.GetValue("Globals", "Author")); al.AddParam("company", "", this.localizer.GetValue("Globals", "Company")); al.AddParam("creationDate", "", this.localizer.GetValue("Globals", "CreationDate")); al.AddParam("exportPrintDate", "", this.localizer.GetValue("Globals", "ExportPrintDate")); al.AddParam("now", "", Convert.ToString(DateTime.Now, DateTimeFormatInfo.InvariantInfo)); al.AddParam("release", "", this.localizer.GetValue("Globals", "Release")); transform.Transform(tr,al,tw,null); tw.Close(); tr.Close(); }
public DotNetCompiledTransform(string sTransformName, string sTargetLanguageCode) : base(sTargetLanguageCode) { var resolver = new XmlUrlResolver(); resolver.Credentials = System.Net.CredentialCache.DefaultCredentials; m_transformer.Load(sTransformName, XsltSettings.TrustedXslt, resolver); }
/// <summary> /// Initializes a new instance of the <see cref="XslCompiler">XslCompiler</see> class. /// </summary> public XslCompiler(string path, string assemblyFilename) { Path = path; Filename = assemblyFilename; TargetProcessor = ImageFileMachine.I386; XsltSettings = new XsltSettings(); XmlResolver = new XmlUrlResolver(); XmlResolver.Credentials = CredentialCache.DefaultCredentials; }
public void Transform(string modelFilePath) { XmlResolver resolver = new XmlUrlResolver(); resolver.Credentials = CredentialCache.DefaultCredentials; XmlTextReader doc = new XmlTextReader(modelFilePath); XslCompiledTransform transform = new XslCompiledTransform(); transform.Load(this.stylesheetFilesPath + Path.DirectorySeparatorChar + "XMI11Export.xsl",null,resolver); transform.Transform(doc,null,new XmlTextWriter(this.xmiFilesPath,Encoding.UTF8),resolver); }
public Stream ImportXmiStream(string filename) { XmlDocument input = GetInputFile (filename); XmlResolver res = new XmlUrlResolver (); XslTransform xslt = GetXslt (input, null, res); MemoryStream output = new MemoryStream (); xslt.Transform (input, new XsltArgumentList (), output, res); return output; }
public void BuildPages(string modelFilePath) { XmlResolver resolver = new XmlUrlResolver(); resolver.Credentials = CredentialCache.DefaultCredentials; XmlDocument doc = new XmlDocument(); doc.XmlResolver = resolver; doc.Load(modelFilePath); XmlNode modelNode = doc.SelectSingleNode("//Model"); this.RecurseNode(modelFilePath, resolver, modelNode,"Package.xsl"); }
public XmlDocument ImportXmi(string filename) { XmlDocument input = GetInputFile (filename); XmlResolver res = new XmlUrlResolver (); XslTransform xslt = GetXslt (input, null, res); XmlReader reader = xslt.Transform (input, new XsltArgumentList (), res); XmlDocument output = new XmlDocument (); output.Load (reader); return output; }
public override object GetEntity(Uri absoluteUri, string role, Type ofObjectToReturn) { string name = absoluteUri.AbsoluteUri.Split(new char[] { '/' }).Last<string>(); byte[] stream = _schemas[name]; if (stream != null) { return new MemoryStream(stream);; } XmlUrlResolver resolver = new XmlUrlResolver(); return resolver.GetEntity(absoluteUri, role, ofObjectToReturn); }
public void Transform(string modelFilePath) { XmlResolver resolver = new XmlUrlResolver(); resolver.Credentials = CredentialCache.DefaultCredentials; XmlDocument doc = new XmlDocument(); doc.XmlResolver = resolver; doc.Load(modelFilePath); XslTransform transform = new XslTransform(); transform.Load(this.stylesheetFilesPath + Path.DirectorySeparatorChar + "XMI11Export.xsl",resolver); StreamWriter sw = new StreamWriter(this.xmiFilesPath,false); transform.Transform(doc,null,sw,null); sw.Close(); }
public static bool SendEmail(SPWeb web, string emailTo, string xslt, IDictionary xslValues) { XmlDocument xmlDoc; XPathNavigator xpathNavigator; XslCompiledTransform xslEmailTransform = new XslCompiledTransform(); XsltArgumentList xslArguments; StringBuilder sbEmail; XmlTextWriter xmlWriter; XmlNode xmlNodeTitle; XmlDocument xmlEmail; XsltSettings settings = new XsltSettings(true, true); XmlUrlResolver resolver = new XmlUrlResolver(); string subject = string.Empty; try { xslEmailTransform.Load(new XmlTextReader(xslt, XmlNodeType.Document, null), settings, resolver); xmlDoc = new XmlDocument(); xmlDoc.AppendChild(xmlDoc.CreateElement("DocumentRoot")); xpathNavigator = xmlDoc.CreateNavigator(); xslArguments = new XsltArgumentList(); if (xslValues != null) { foreach (DictionaryEntry xslEntry in xslValues) { xslArguments.AddExtensionObject(xslEntry.Key.ToString(), xslEntry.Value); } } sbEmail = new StringBuilder(); xmlWriter = new XmlTextWriter(new StringWriter(sbEmail)); xslEmailTransform.Transform(xpathNavigator, xslArguments, xmlWriter); xmlEmail = new XmlDocument(); xmlEmail.LoadXml(sbEmail.ToString()); xmlNodeTitle = xmlEmail.SelectSingleNode("//title"); subject = xmlNodeTitle.InnerText; return SendEmail(web, emailTo, subject, sbEmail.ToString()); } catch (Exception ex) { Utils.LogError(ex); return false; } }
private void openToolStripMenuItem_Click(object sender, EventArgs e) { OpenFileDialog dialog = new OpenFileDialog(); dialog.Filter = "xml files (*.xml)|*.xml|All files (*.*)|*.*"; if (dialog.ShowDialog() == DialogResult.OK) { XmlDataDocument xmldoc = new XmlDataDocument(); XmlReaderSettings settings = new XmlReaderSettings(); settings.IgnoreWhitespace = true; settings.ProhibitDtd = false; XmlUrlResolver resolver = new XmlUrlResolver(); resolver.Credentials = CredentialCache.DefaultCredentials; settings.XmlResolver = resolver; XmlReader render = XmlReader.Create(dialog.FileName, settings); try { try { xmldoc.Load(render); } catch (Exception ex) { MessageBox.Show(this, ex.Message, "Parse Error", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } } finally { render.Close(); } GridBuilder builder = new GridBuilder(); if (xmlGrid.ShowColumnHeader) { GridCellGroup xmlgroup = new GridCellGroup(); xmlgroup.Flags = GroupFlags.Overlapped | GroupFlags.Expanded; builder.ParseNodes(xmlgroup, null, xmldoc.ChildNodes); GridCellGroup root = new GridCellGroup(); root.Table.SetBounds(1, 2); root.Table[0, 0] = new GridHeadLabel(); root.Table[0, 0].Text = dialog.FileName; root.Table[0, 1] = xmlgroup; xmlGrid.Cell = root; } else { GridCellGroup root = new GridCellGroup(); builder.ParseNodes(root, null, xmldoc.ChildNodes); xmlGrid.Cell = root; } } }
private void Init (HttpContext context) { AppSettings baseXslt = new AppSettings(); String xsltUri = context.Server.MapPath(baseXslt.GetSetting("baseTemplate")); Uri xUri = new Uri(xsltUri); this._Resolver = new XmlUrlResolver(); this._Resolver.Credentials = CredentialCache.DefaultCredentials; this._TemplateStream = (Stream)this._Resolver.GetEntity(xUri, null, typeof(Stream)); this._Processor = new Processor(); this._Compiler = _Processor.NewXsltCompiler(); this._Compiler.BaseUri = xUri; this._Template = this._Compiler.Compile(_TemplateStream); this._IS_INITIALIZED = true; }
/// <summary> /// Transform data. /// </summary> /// <param name="xmlData"> The xml data to load.</param> /// <param name="stylesheet"> The style sheet data to load.</param> /// <returns> A string containing the html report.</returns> public string TransformFromData(string xmlData, string stylesheet) { // new XmlDocument, adds a xml using GetXml() XmlDocument root = new XmlDocument(); root.LoadXml(xmlData); XPathNavigator nav = root.CreateNavigator(); // xml resolver XmlUrlResolver resolver = new XmlUrlResolver(); resolver.Credentials=System.Net.CredentialCache.DefaultCredentials; // evidence //Evidence ev = XmlSecureResolver.CreateEvidenceForUrl(stylesheet); StringWriter output = null; XmlTextReader reader = null; try { // XmlReader //StreamReader stm = new StreamReader(st,System.Text.Encoding.Default); StringReader sreader = new StringReader(stylesheet); reader = new XmlTextReader(sreader); XslTransform xslt = new XslTransform(); output = new StringWriter(); // load xslt.Load(reader, resolver, null); // transform xslt.Transform(nav,null,output,resolver); return output.ToString(); } catch { throw; } finally { if ( output != null ) output.Close(); if ( reader != null ) reader.Close(); } }
public void ProcessRequest(HttpContext context) { _requestMethod = context.Request.HttpMethod; _writer = context.Response.Output; _context = context; _processor = (Processor)context.Application["processor"]; _compiler = (XsltCompiler)context.Application["compiler"]; _serializer = (Serializer)context.Application["serializer"]; _resolver = (XmlUrlResolver)context.Application["resolver"]; _globalXsltParams = (Hashtable)context.Application["globalXsltParams"]; _sessionXsltParams = (Hashtable)context.Application["sessionXsltParams"]; _requestXsltParams = (Hashtable)context.Application["requestXsltParams"]; Hashtable xsltParams = new Hashtable(); foreach (DictionaryEntry param in _globalXsltParams) { xsltParams[param.Key] = param.Value; } foreach (DictionaryEntry param in _sessionXsltParams) { xsltParams[param.Key] = param.Value; } foreach (DictionaryEntry param in _requestXsltParams) { xsltParams[param.Key] = param.Value; } _transformContext = new Context(context, _processor, _compiler, _serializer, _resolver, xsltParams); switch (_requestMethod) { case "GET": { new Transform().Process(_transformContext); break; } case "PUT": { new Transform().Process(_transformContext); break; } case "POST": { new Transform().Process(_transformContext); break; } case "DELETE": { new Transform().Process(_transformContext); break; } default: { new Transform().Process(_transformContext); break; } } }
public Form1() { InitializeComponent(); XmlUrlResolver resolver = new XmlUrlResolver(); Uri myUri = new Uri("http://dgcsc.org/goldprices.xml"); Stream s = (Stream)resolver.GetEntity(myUri, null, typeof(Stream)); // Construct a reader using the Stream object. XmlTextReader xmlTextReader = new XmlTextReader(s); XmlDataDocument xdoc1 = new XmlDataDocument(); xdoc1.DataSet.ReadXml(xmlTextReader, XmlReadMode.Auto); DataSet ds = xdoc1.DataSet; //DataTable dt = ds; dataGridView1.DataSource = ds.Tables[1]; }
public static XmlDocument GetXmlDocument(string url, ICredentials credentials) { XmlUrlResolver resolver = new XmlUrlResolver { Credentials = credentials ?? CredentialCache.DefaultCredentials }; XmlReaderSettings settings = new XmlReaderSettings { XmlResolver = resolver }; XmlReader reader = XmlReader.Create(url, settings); XmlDocument document = new XmlDocument(); document.Load(reader); return document; }
//--- Class Methods --- private static void Main() { var config = Config.NewConfig(Path.Combine(Location, "config.xml")); Console.WriteLine("BUILDING: Setting assembly name to " + ASSEMBLY_NAME); var assembly = new AssemblyName { Name = ASSEMBLY_NAME }; if(config.Version != null) { Console.WriteLine("BUILDING: Setting assembly version to " + config.Version); assembly.Version = config.Version; } var assemblyFile = assembly.Name + ".dll"; var assemblyBuilder = Thread.GetDomain().DefineDynamicAssembly(assembly, AssemblyBuilderAccess.Save); _moduleBuilder = assemblyBuilder.DefineDynamicModule(assembly.Name, assemblyFile); var xsltReaderSettings = new XmlReaderSettings { ProhibitDtd = false }; var resolver = new XmlUrlResolver(); foreach(var xslt in config.Xslts) { try { if(!string.IsNullOrEmpty(xslt.EmbedPath)) { Console.WriteLine(string.Format("BUILDING ({0}): Embedding resources", xslt.Id)); EmbedResources(xslt); } var type = NAMESPACE + xslt.Type; Console.WriteLine(string.Format("BUILDING ({0}): Defining type {1}", xslt.Id, type)); var typeBuilder = _moduleBuilder.DefineType(type, TypeAttributes.Public | TypeAttributes.Class); var xsl = PathUtil.GetNormalizedFilename(Path.Combine(Location, xslt.XslPath)); var xsltReader = XmlReader.Create(xsl, xsltReaderSettings); var xsltSettings = new XsltSettings { EnableDocumentFunction = true }; Console.WriteLine(string.Format("BUILDING ({0}): Compiling xslt", xslt.Id)); XslCompiledTransform.CompileToType(xsltReader, xsltSettings, resolver, false, typeBuilder, null); } catch { CleanUp(); throw; } } Console.WriteLine("BUILDING: Setting assembly title attribute"); SetAssemblyAttribute(assemblyBuilder, typeof(AssemblyTitleAttribute), assembly.Name); Console.WriteLine("BUILDING: Setting assembly product attribute"); SetAssemblyAttribute(assemblyBuilder, typeof(AssemblyProductAttribute), assembly.Name); Console.WriteLine("BUILDING: Setting assembly company attribute"); SetAssemblyAttribute(assemblyBuilder, typeof(AssemblyCompanyAttribute), "MindTouch, Inc."); Console.WriteLine("BUILDING: Setting assembly copyright attribute"); SetAssemblyAttribute(assemblyBuilder, typeof(AssemblyCopyrightAttribute), "Copyright (c) 2006-2012"); Console.WriteLine(string.Format("BUILDING: Saving assembly {0}", assemblyFile)); assemblyBuilder.Save(assemblyFile); Console.WriteLine("BUILDING: Cleaning up"); CleanUp(); }
/// <summary> /// Gets XmlResolver - default or custom, with user credentials or not. /// </summary> /// <param name="credentials">User credentials</param> /// <param name="options">Parsed command line options</param> public static XmlResolver GetXmlResolver(NetworkCredential credentials, NXsltOptions options, bool prohibitDTD) { XmlResolver resolver; Type resolverType; if (options.ResolverTypeName != null) { //Custom resolver try { resolverType = TypeUtils.FindType(options, options.ResolverTypeName); } catch (Exception e) { throw new NXsltException(NXsltStrings.ErrorCreateResolver, options.ResolverTypeName, e.Message); } if (!typeof(XmlResolver).IsAssignableFrom(resolverType)) { //Type is not XmlResolver throw new NXsltException(NXsltStrings.ErrorTypeNotXmlResolver, options.ResolverTypeName); } try { resolver = (XmlResolver)Activator.CreateInstance(resolverType); } catch (Exception e) { throw new NXsltException(NXsltStrings.ErrorCreateResolver, options.ResolverTypeName, e.Message); } } else { if (prohibitDTD) { resolver = new XmlUrlResolver(); } else { resolver = new DTDAllowingResolver(); } } //Set credentials if any if (credentials != null) { resolver.Credentials = credentials; } return resolver; }
public static void TransformXML() { // Create a resolver with default credentials. XmlUrlResolver resolver = new XmlUrlResolver(); resolver.Credentials = System.Net.CredentialCache.DefaultCredentials; // transform the personnel.xml file to HTML XslTransform transform = new XslTransform(); // load up the stylesheet transform.Load(@"C:\Users\Usuario\Desktop\SVN\PDV\DLL\2.xsl", resolver); // perform the transformation transform.Transform(@"C:\temp\100.xml", @"C:\temp\Personnel.html", resolver); // transform the personnel.xml file to comma delimited format // load up the stylesheet // transform.Load(@"..\PersonnelCSV.xsl", resolver); // perform the transformation // transform.Transform(@"..\Personnel.xml", @"..\Personnel.csv", resolver); }
public void Convert(string inputfile, string outputfile) { // loads the input file XmlDocument input = GetInputFile (inputfile); // generates the output XmlTextWriter output = outputfile==null ? new XmlTextWriter(Console.Out) : new XmlTextWriter( outputfile, Encoding.GetEncoding("ISO-8859-15")); output.Formatting = Formatting.Indented; System.Security.Policy.Evidence evidence = outputfile==null ? null : XmlSecureResolver.CreateEvidenceForUrl("file://" + outputfile); XmlResolver res = new XmlUrlResolver (); XslTransform xslt = GetXslt (input, evidence, res); xslt.Transform(input, new XsltArgumentList (), output, res); output.WriteRaw(System.Environment.NewLine); }
public XsltTransformationManager ( Processor processor, Transform transform, XmlUrlResolver resolver, Serializer serializer, Hashtable xsltHashtable, Hashtable xmlSourceHashtable, Hashtable xdmNodeHashtable, Hashtable namedXsltHashtable, Hashtable namedXsltETagIndex, Hashtable xdmNodeETagIndex, Uri baseXsltUri, String baseXsltUriHash, String baseXsltName ) { _baseXsltUri = baseXsltUri; _baseXsltUriHash = baseXsltUriHash; _baseXsltName = baseXsltName; _transform = transform; _xsltHashtable = xsltHashtable; _processor = processor; _compiler = _processor.NewXsltCompiler(); _sourceHashtable = xmlSourceHashtable; _resolver = resolver; _compiler.XmlResolver = _resolver; _builder = _processor.NewDocumentBuilder(); _serializer = serializer; _xdmNodeHashtable = xdmNodeHashtable; _xdmNodeETagIndex = xdmNodeETagIndex; _namedXsltHashtable = namedXsltHashtable; _namedXsltETagIndex = namedXsltETagIndex; _hashAlgorithm = HashAlgorithm.SHA1; //NOTE: TransformEngine enum PLACEHOLDER FOR FUTURE USE _transformEngine = TransformEngine.SAXON; }
public void BuildNavigator(string modelFilePath) { XmlResolver resolver = new XmlUrlResolver(); resolver.Credentials = CredentialCache.DefaultCredentials; XmlDocument doc = new XmlDocument(); doc.XmlResolver = resolver; doc.Load(modelFilePath); XslTransform transform = new XslTransform(); transform.Load(this.stylesheetFilesPath + Path.DirectorySeparatorChar + "ModelTree.xsl",resolver); StreamWriter sw = new StreamWriter(this.htmlFilesPath + Path.DirectorySeparatorChar + "ModelTree.htm",false); XsltArgumentList al = new XsltArgumentList(); al.AddParam("modelBrowser","",this.localizer.GetValue("Globals","ModelBrowser")); al.AddParam("glossary","",this.localizer.GetValue("Globals","Glossary")); transform.Transform(doc,al,sw,null); sw.Close(); transform.Load(this.stylesheetFilesPath + Path.DirectorySeparatorChar + "HomePage.xsl",resolver); sw = new StreamWriter(this.htmlFilesPath + Path.DirectorySeparatorChar + "main.htm",false); al = new XsltArgumentList(); AssemblyName an = this.GetType().Assembly.GetName(); al.AddParam("version","",an.Version.ToString(3)); transform.Transform(doc,al,sw,null); sw.Close(); }
/// <summary> /// Pres the process. /// </summary> /// <param name="input">The input.</param> /// <param name="output">The output.</param> /// <param name="resolver">The resolver.</param> /// <param name="inputUri">The input_uri.</param> /// <returns></returns> /// <remarks></remarks> public PreprocessorEnvironment PreProcess(XmlReader input, XmlWriter output, XmlUrlResolver resolver, Uri inputUri) { // The base URI is needed to resolve includes of relative paths, as well as to generate // error messages. // If none is given explicitly, try to use the XmlReader's BaseUri. // If that doesn't exist either, use the current working directory and a fake filename. Uri base_uri = inputUri ?? ( String.IsNullOrEmpty( input.BaseURI ) ? new Uri( Path.Combine( Environment.CurrentDirectory, "nofile.xml" ) ) : new Uri( input.BaseURI ) ); // Create the environment _env = new PreprocessorEnvironment( _settings, base_uri, resolver ); // Load the input document XDocument doc = XDocument.Load( input, LoadOptions.PreserveWhitespace | LoadOptions.SetBaseUri | LoadOptions.SetLineInfo ); // Process the input document's nodes and write the results to the output stream foreach ( XNode out_node in doc.Nodes().SelectMany( node => _env._DefaultNodeProcessor.Process( node ) ).Where( node => !(node is XText)) ) { out_node.WriteTo( output ); } // Notify listeners of all files encountered. if (SubfileLoaded != null) { foreach (Uri path in _env.Fileset) { SubfileLoaded( path ); } } return _env; }
public XsltTransformationManager ( Processor processor, Transform transform, XmlUrlResolver resolver, Serializer serializer, Dictionary<string, XsltTransformer> xsltHashtable, Hashtable xmlSourceHashtable, Hashtable xdmNodeHashtable, Hashtable namedXsltHashtable, Hashtable namedXsltETagIndex, Hashtable xdmNodeETagIndex, Uri baseXsltUri, String baseXsltUriHash, String baseXsltName ) { m_baseXsltUri = baseXsltUri; m_baseXsltUriHash = baseXsltUriHash; m_baseXsltName = baseXsltName; m_transform = transform; m_xsltHashtable = xsltHashtable; m_processor = processor; m_compiler = m_processor.NewXsltCompiler(); m_sourceHashtable = xmlSourceHashtable; m_resolver = resolver; m_compiler.XmlResolver = m_resolver; m_builder = m_processor.NewDocumentBuilder(); m_serializer = serializer; m_xdmNodeHashtable = xdmNodeHashtable; m_xdmNodeETagIndex = xdmNodeETagIndex; m_namedXsltHashtable = namedXsltHashtable; m_namedXsltETagIndex = namedXsltETagIndex; m_hashAlgorithm = HashAlgorithm.MD5; //NOTE: TransformEngine enum PLACEHOLDER FOR FUTURE USE m_transformEngine = TransformEngine.SAXON; }
static void Main(string[] args) { Console.WriteLine("Demo1:\n"); XslCompiledTransform trans = new XslCompiledTransform(); trans.Load(@"..\..\books.xsl"); trans.Transform(@"..\..\books.xml", "out.html"); Console.WriteLine("Your Demo:\n"); // Create a resolver with default credentials. XmlUrlResolver resolver = new XmlUrlResolver(); resolver.Credentials = System.Net.CredentialCache.DefaultCredentials; // transform the personnel.xml file to HTML XslTransform transform = new XslTransform(); // load up the stylesheet transform.Load(@"..\..\PersonnelHTML.xsl", resolver); // perform the transformation transform.Transform(@"..\..\Personnel.xml", @"Personnel.html", resolver); // transform the personnel.xml file to comma delimited format // load up the stylesheet transform.Load(@"..\..\PersonnelCSV.xsl", resolver); // perform the transformation transform.Transform(@"..\..\Personnel.xml", @"Personnel1.csv", resolver); }
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; }
internal DTDValidatingReader (XmlReader reader, XmlValidatingReader validatingReader) { this.reader = new EntityResolvingXmlReader (reader); this.sourceTextReader = reader as XmlTextReader; elementStack = new Stack (); automataStack = new Stack (); attributes = new AttributeSlot [10]; nsmgr = new XmlNamespaceManager (reader.NameTable); this.validatingReader = validatingReader; valueBuilder = new StringBuilder (); idList = new ArrayList (); missingIDReferences = new ArrayList (); XmlTextReader xtReader = reader as XmlTextReader; if (xtReader != null) { resolver = xtReader.Resolver; } else resolver = new XmlUrlResolver (); }
[Test] // bug #998 public void NullAbsoluteUriWithCustomSchemedRelativeUri () { XmlResolver res = new XmlUrlResolver (); var uri = res.ResolveUri (null, "view:Standard.xslt"); Assert.AreEqual ("view", uri.Scheme, "#1"); Assert.AreEqual ("Standard.xslt", uri.AbsolutePath, "#2"); Assert.AreEqual ("view:Standard.xslt", uri.AbsoluteUri, "#2"); }
public void GetReady () { resolver = new XmlUrlResolver (); }
internal XmlReader AddValidation(XmlReader reader) { if (_validationType == ValidationType.Schema) { XmlResolver resolver = GetXmlResolver_CheckConfig(); if (resolver == null && !this.IsXmlResolverSet && !EnableLegacyXmlSettings()) { resolver = new XmlUrlResolver(); } reader = new XsdValidatingReader(reader, resolver, this); } else if (_validationType == ValidationType.DTD) { reader = CreateDtdValidatingReader(reader); } return reader; }