public void Load(Compiler compiler, object stylesheet, XmlResolver xmlResolver)
{
Debug.Assert(compiler != null);
_compiler = compiler;
_xmlResolver = xmlResolver ?? XmlNullResolver.Singleton;
XmlReader reader = stylesheet as XmlReader;
if (reader != null)
{
_readerSettings = new QueryReaderSettings(reader);
Load(reader);
}
else
{
// We should take DefaultReaderSettings from Compiler.Settings.DefaultReaderSettings.
string uri = stylesheet as string;
if (uri != null)
{
// If xmlResolver == null, then the original uri will be resolved using XmlUrlResolver
XmlResolver origResolver = xmlResolver;
if (xmlResolver == null || xmlResolver == XmlNullResolver.Singleton)
origResolver = new XmlUrlResolver();
Uri resolvedUri = origResolver.ResolveUri(null, uri);
if (resolvedUri == null)
{
throw new XslLoadException(SR.Xslt_CantResolve, uri);
}
_readerSettings = new QueryReaderSettings(new NameTable());
using (reader = CreateReader(resolvedUri, origResolver))
{
Load(reader);
}
}
else
{
IXPathNavigable navigable = stylesheet as IXPathNavigable;
if (navigable != null)
{
reader = XPathNavigatorReader.Create(navigable.CreateNavigator());
_readerSettings = new QueryReaderSettings(reader.NameTable);
Load(reader);
}
else
{
Debug.Fail("Should never get here");
}
}
}
Debug.Assert(compiler.Root != null);
compiler.StartApplyTemplates = f.ApplyTemplates(nullMode);
ProcessOutputSettings();
foreach (AttributeSet attSet in compiler.AttributeSets.Values)
{
CheckAttributeSetsDfs(attSet); // Check attribute sets for circular references using dfs marking method
}
}
//==============================
//
static void XSLT_Old()
{
string filename = "books.xml";
//<snippet7>
// Create the XslTransform.
XslTransform xslt = new XslTransform();
// Create a resolver and set the credentials to use.
XmlUrlResolver resolver = new XmlUrlResolver();
resolver.Credentials = CredentialCache.DefaultCredentials;
// Load the style sheet.
xslt.Load("http://serverName/data/xsl/sort.xsl", resolver);
// Transform the file.
XPathDocument doc = new XPathDocument(filename);
XmlTextWriter writer = new XmlTextWriter("output.xml", null);
xslt.Transform(doc, null, writer, null);
//</snippet7>
}
static void Main(string[] args)
{
//This example gets all the Tables in the specified spreadsheet and lists them
//Note: Check that the Excel Services service application is running before you run this example
//Get a reference to the atom namespace
XNamespace atomNS = atomNameSpace;
//build the relative Url to the excel workbook model
string relativeUrl = "/_vti_bin/ExcelRest.aspx/" + docLibrary + "/" + spreadsheetFileName + "/model/Tables";
//Use an XMLUrlResolver object to pass credentials to the REST service
XmlUrlResolver resolver = new XmlUrlResolver();
resolver.Credentials = CredentialCache.DefaultCredentials;
//Build the URI to pass the the resolver
Uri baseUri = new Uri(sharepointSite);
Uri fullUri = resolver.ResolveUri(baseUri, relativeUrl);
//Tell the user what the stream address is
Console.WriteLine("Opening this stream: " + fullUri.ToString());
//Call the resolver and receive the ATOM feed as a result
Stream atomStream = (Stream)resolver.GetEntity(fullUri, null, typeof(Stream));
//Load the stream into an XDocument
XDocument atomResults = XDocument.Load(atomStream);
//Query the XDocument for all title elements that are children of an entry element
IEnumerable <XElement> tables =
from t in atomResults.Descendants(atomNS + "title")
where t.Parent.Name == atomNS + "entry"
select t;
Console.WriteLine("Tables in the spreadsheet " + spreadsheetFileName + ":");
//Display each of the table
foreach (XElement table in tables)
{
Console.WriteLine((string)table);
}
//This line prevents the console disappearing before you can read the result
//Alternatively, remove this line a run the project without debugging (CTRL-F5)
Console.ReadKey();
}
public string GetOriginalChain(string stringXML)
{
StringWriter sw = new StringWriter();
try
{
XslCompiledTransform xslt = new System.Xml.Xsl.XslCompiledTransform();
XsltSettings sets = new XsltSettings(true, true);
var resolver = new XmlUrlResolver();
xslt.Load(xsltPath, sets, resolver);
XmlDocument FromXmlFile = new System.Xml.XmlDocument();
FromXmlFile.LoadXml(stringXML);
xslt.Transform(FromXmlFile, null, sw);
}
catch (Exception ex)
{
throw new Exception("No se pudo generar la cadena", ex.InnerException);
}
return(sw.ToString());
}
private XmlReaderSettings BuildXmlReaderSettings(bool isDtdProcessing, XsdInfo xsdInfo)
{
// Set the validation settings.
XmlReaderSettings settings = new XmlReaderSettings();
settings.ValidationType = ValidationType.Schema;
//Removed for Issue#2 on Codeplex
//settings.ValidationFlags |= XmlSchemaValidationFlags.ProcessSchemaLocation;
settings.ValidationEventHandler += new ValidationEventHandler(ValidationCallBack);
//Allow DTD processing
if (isDtdProcessing)
{
settings.DtdProcessing = DtdProcessing.Parse;
}
else
{
settings.DtdProcessing = DtdProcessing.Prohibit;
}
// Supply the credentials necessary to access the DTD file stored on the network.
XmlUrlResolver resolver = new XmlUrlResolver();
resolver.Credentials = System.Net.CredentialCache.DefaultCredentials;
settings.XmlResolver = resolver;
//Get the Schema
// A Stream is needed to read the XSD document contained in the assembly.
if (xsdInfo != null)
{
settings.ValidationFlags |= XmlSchemaValidationFlags.ReportValidationWarnings;
using (Stream stream = Assembly.GetExecutingAssembly()
.GetManifestResourceStream(xsdInfo.ResourceName))
{
settings.Schemas.Add(xsdInfo.TargetNamespace, XmlReader.Create(stream));
settings.Schemas.Compile();
}
}
return(settings);
}
public net.sf.saxon.om.SequenceIterator resolve(string href, string baseStr, net.sf.saxon.expr.XPathContext context)
{
try {
List <Uri> docs;
if (href == null)
{
docs = (List <Uri>)collections[new Uri("http://www.saxonica.com/defaultCollection")];
}
else
{
XmlUrlResolver res = new XmlUrlResolver();
Uri abs = res.ResolveUri(new Uri(baseStr), href);
try
{
docs = (List <Uri>)collections[abs];
}
catch (Exception) {
docs = null;
}
}
if (docs == null)
{
return(net.sf.saxon.tree.iter.EmptyIterator.getInstance());
}
else
{
java.util.List list = new java.util.ArrayList();
foreach (Uri uri in docs)
{
list.add(new net.sf.saxon.value.AnyURIValue(uri.ToString()));
}
return(new net.sf.saxon.tree.iter.ListIterator(list));
}
} catch (java.net.URISyntaxException e) {
System.Console.WriteLine("** Invalid Uri: " + e.Message);
return(net.sf.saxon.tree.iter.EmptyIterator.getInstance());
}
}
/// <include file='doc\xml.uex' path='docs/doc[@for="Xml.Render"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
protected override void Render(HtmlTextWriter output)
{
// If we don't already have an XmlDocument, load am XPathDocument (which is faster)
if (_document == null)
{
LoadXPathDocument();
}
LoadTransformFromSource();
if (_document == null && _xpathDocument == null)
{
return;
}
// If we don't have a transform, use the identity transform, which
// simply renders the XML.
if (_transform == null)
{
_transform = _identityTransform;
}
// Pass a resolver in full trust, to support certain XSL scenarios (ASURT 141427)
XmlUrlResolver xr = null;
if (HttpRuntime.HasUnmanagedPermission())
{
xr = new XmlUrlResolver();
}
if (_document != null)
{
Transform.Transform(_document, _transformArgumentList, output, xr);
}
else
{
Transform.Transform(_xpathDocument, _transformArgumentList, output, xr);
}
}
private void buttonsubmit_Click(object sender, EventArgs e)
{
string path = textBoxPath.Text;
textBoxPath.Text = "";
XmlUrlResolver resolver = new XmlUrlResolver();
resolver.Credentials = System.Net.CredentialCache.DefaultCredentials;
xmlDoc.XmlResolver = resolver;
try
{
xmlDoc.Load(path); //Durch die Load Methode wird eine XML-Datei geladen. Die XML-Datei liegt im Verzeichnis"Debug".
kontextNode = xmlDoc; //kontextNode wird auf das Dokument initialisiert.
tbAusgabetextBox.Text = AusgabeString(kontextNode);
}
catch (Exception ex)
{
Console.WriteLine("{0}:{1}", ex.GetType(), ex.Message);
StatusLabel.Text = ex.GetType().ToString();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="XmlValidatingLoader" /> class.
/// </summary>
/// <param name="innerReader">The inner reader.</param>
/// <remarks></remarks>
public XmlValidatingLoader(XmlReader innerReader)
{
this.innerReader = innerReader;
var resolver = new XmlUrlResolver();
// This is a bit of a hack - Turn on DTD entity resolution if it is not already on.
// Also set a resolver, this is required under Mono
var dummy = innerReader as XmlTextReader;
if (dummy != null)
{
dummy.EntityHandling = EntityHandling.ExpandEntities;
dummy.XmlResolver = resolver;
}
xmlReaderSettings = new XmlReaderSettings();
xmlReaderSettings.ValidationType = ValidationType.None;
xmlReaderSettings.ProhibitDtd = false;
xmlReaderSettings.XmlResolver = resolver;
xmlReaderSettings.ConformanceLevel = ConformanceLevel.Auto;
xmlReaderSettings.ValidationEventHandler += ValidationHandler;
}
public void WithInitializeInsideIf(XmlUrlResolver xmlUrlResolver)
{
XmlDocument doc;
if ((doc = new XmlDocument()) != null)
{
doc.XmlResolver = null; // no DTD resolving
doc.Load("");
}
if ((doc = new XmlDocument()) != null) // Noncompliant
{
doc.XmlResolver = xmlUrlResolver; // Noncompliant
doc.Load("");
}
if ((doc = new XmlDocument()) != null)
{
doc.XmlResolver = null; // no DTD resolving
doc.Load("");
}
}
public static string CadenaOriginalCFDIv33(string strXml)
{
try
{
var xslt_cadenaoriginal_3_3 = new XslCompiledTransform();
XsltSettings settings = new XsltSettings(true, true);
XmlUrlResolver resolver = new XmlUrlResolver();
xslt_cadenaoriginal_3_3.Load("Resources/XSLT/cadenaoriginal_3_3.xslt", settings, resolver);
string resultado = null;
StringWriter writer = new StringWriter();
XmlReader xml = XmlReader.Create(new StringReader(strXml));
xslt_cadenaoriginal_3_3.Transform(xml, null, writer);
resultado = writer.ToString().Trim();
writer.Close();
return(resultado);
}
catch (Exception ex)
{
throw new Exception("El XML proporcionado no es válido.", ex);
}
}
static void Main(string[] args)
{
// Create and load the transform with script execution enabled.
XslCompiledTransform transform = new XslCompiledTransform();
XsltSettings settings = new XsltSettings();
settings.EnableScript = true;
XmlUrlResolver resolver = new XmlUrlResolver();
// transform the Schematron to a XSL
transform.Load(@"D:\VisualStudio Projects\HL7\SchematronTry.ConsoleApplication\iso-schematron-xslt1\iso_svrl_for_xslt1.xsl", settings, resolver);
transform.Transform(@"D:\VisualStudio Projects\HL7\SchematronTry.ConsoleApplication\Test.sch",
@"D:\VisualStudio Projects\HL7\SchematronTry.ConsoleApplication\Test.sch.xsl");
// now execute the Schematron XSL
const string fm_max_file = @"D:\My Documents\__R4C\__WIP\HL7 EHR-S FM Tooling (2012-aug)\EHRS_FM_R2 (import v2.2) generated-ehrs-fm-20121115-full2.max.xml";
//const string fm_max_file = @"D:\VisualStudio Projects\HL7\SchematronTry.ConsoleApplication\fm-max.xml";
transform.Load(@"D:\VisualStudio Projects\HL7\SchematronTry.ConsoleApplication\Test.sch.xsl", settings, resolver);
transform.Transform(fm_max_file, @"D:\VisualStudio Projects\HL7\SchematronTry.ConsoleApplication\fm-max.xml-output");
}
public XmlSchema Add(string targetNamespace, string schemaUri)
{
if ((schemaUri == null) || (schemaUri.Length == 0))
{
throw new ArgumentNullException("schemaUri");
}
if (targetNamespace != null)
{
targetNamespace = XmlComplianceUtil.CDataNormalize(targetNamespace);
}
XmlSchema schema = null;
lock (this.InternalSyncObject)
{
System.Xml.XmlResolver xmlResolver = this.readerSettings.GetXmlResolver();
if (xmlResolver == null)
{
xmlResolver = new XmlUrlResolver();
}
Uri uri = xmlResolver.ResolveUri(null, schemaUri);
if (this.IsSchemaLoaded(uri, targetNamespace, out schema))
{
return(schema);
}
XmlReader reader = XmlReader.Create(schemaUri, this.readerSettings);
try
{
schema = this.Add(targetNamespace, this.ParseSchema(targetNamespace, reader));
while (reader.Read())
{
}
}
finally
{
reader.Close();
}
}
return(schema);
}
// Load URI with XmlResolver
static void Settings_Resolver()
{
string UserName = "******";
string SecurelyStoredPassword = "******";
string Domain = "domain";
//<snippet2>
// Create an XmlUrlResolver with the credentials necessary to access the Web server.
XmlUrlResolver resolver = new XmlUrlResolver();
System.Net.NetworkCredential myCred;
myCred = new System.Net.NetworkCredential(UserName, SecurelyStoredPassword, Domain);
resolver.Credentials = myCred;
XmlReaderSettings settings = new XmlReaderSettings();
settings.XmlResolver = resolver;
// Create the reader.
XmlReader reader = XmlReader.Create("http://serverName/data/books.xml", settings);
//</snippet2>
}
protected override ActivityExecutionStatus Execute(ActivityExecutionContext context)
{
string sFullURL = this.SourceSiteURL + @"/" + this.DocumentLibrary + @"/" + this.RuleSetName + ".ruleset";
WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer();
XmlUrlResolver resolver = new XmlUrlResolver();
System.Net.NetworkCredential myCredentials = new System.Net.NetworkCredential("Administrator", "password", "Mossb2tr");
resolver.Credentials = myCredentials;
XmlReaderSettings settings = new XmlReaderSettings();
settings.XmlResolver = resolver;
XmlReader reader = XmlReader.Create(sFullURL, settings);
RuleSet ruleSet = (RuleSet)serializer.Deserialize(reader);
reader.Close();
Activity targetActivity = Utility.GetRootWorkflow(this.Parent);
RuleValidation validation = new RuleValidation(targetActivity.GetType(), null);
RuleExecution execution = new RuleExecution(validation, targetActivity, context);
ruleSet.Execute(execution);
return(ActivityExecutionStatus.Closed);
}
static void SaveAsXml(string url, string fileToSave)
{
if (File.Exists(fileToSave))
{
return;
}
var stream = new XmlUrlResolver().GetEntity(new Uri(url), null, typeof(Stream)) as Stream;
var xr = new SgmlReader()
{
InputStream = new StreamReader(stream)
};
var xw = XmlWriter.Create(fileToSave);
xr.MoveToContent();
do
{
xw.WriteNode(xr, false);
xw.Flush();
} while (xr.Read());
xw.Close();
}
private string DoTransform(string XML, string XSL, XsltArgumentList Params)
{
try
{
XslTransform oXsl = new XslTransform();
oXsl.Load(XSL);
XmlTextReader oXR = new XmlTextReader(XML, XmlNodeType.Document, null);
XPathDocument oXml = new XPathDocument(oXR);
XmlUrlResolver oResolver = new XmlUrlResolver();
StringBuilder oSB = new StringBuilder();
StringWriter oWriter = new StringWriter(oSB, null);
oXsl.Transform(oXml, Params, oWriter, oResolver);
oWriter.Close();
return(oSB.ToString());
}
catch (Exception ex)
{
throw (ex);
}
}
public string Validate(string filename, Stream sourceDoc)
{
var xsltArguments = CreateXsltArguments(filename);
XPathDocument myXPathDocument = new XPathDocument(sourceDoc);
XslTransform myXslTransform = new XslTransform();
var resolver = new XmlUrlResolver();
myXslTransform.Load(_xslPath, resolver);
try
{
using (var output = new MemoryStream())
myXslTransform.Transform(myXPathDocument, xsltArguments, output);
}
catch (XsltException ex)
{
return(ex.Message);
}
return(null);
}
public void WriteToExcel(string Dir, string Filename, string Xslname, string Query, Int16 Limit)
{
DataSet ds = new DataSet();
// Dim fn, str As String
string str = null;
long i = 0;
long j = 0;
//Dim d As Directory
j = 0;
SqlDataAdapter da = new SqlDataAdapter(Query, con);
da.Fill(ds);
da.Dispose();
if (!Directory.Exists(Dir))
{
Directory.CreateDirectory(Dir);
}
for (i = 1; i <= ds.Tables[0].Rows.Count; i += Limit)
{
str = Query + " and num between " + i + " and " + (i + Limit - 1);
SqlDataAdapter da1 = new SqlDataAdapter(str, con);
DataSet DS2 = new DataSet();
da1.Fill(DS2);
XmlDataDocument xdd = new XmlDataDocument(DS2);
//Dim xt As New Xsl.XslTransform
System.Xml.Xsl.XslTransform xt = new System.Xml.Xsl.XslTransform();
xt.Load(Xslname);
FileStream fs = new FileStream(Dir + "\\" + Filename + j + ".xls", System.IO.FileMode.CreateNew, System.IO.FileAccess.Write);
XmlUrlResolver rs = new XmlUrlResolver();
rs.Credentials = System.Net.CredentialCache.DefaultCredentials;
xt.Transform(xdd, null, fs, rs);
fs.Close();
j = j + 1;
DS2.Dispose();
}
}
/// <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 static void Main()
{
//Create the XslTransform.
XslTransform xslt = new XslTransform();
//Create a resolver and set the credentials to use.
XmlUrlResolver resolver = new XmlUrlResolver();
resolver.Credentials = CredentialCache.DefaultCredentials;
//Load the stylesheet.
xslt.Load(stylesheet, resolver);
//Load the XML data file.
XPathDocument doc = new XPathDocument(filename);
//Create the XmlTextWriter to output to the console.
XmlTextWriter writer = new XmlTextWriter(Console.Out);
//Transform the file.
xslt.Transform(doc, null, writer, null);
writer.Close();
}
public void Load(string url, XmlResolver resolver)
{
XmlResolver res = resolver;
if (res == null)
{
res = new XmlUrlResolver();
}
Uri uri = res.ResolveUri(null, url);
using (Stream s = res.GetEntity(uri, null, typeof(Stream)) as Stream) {
XmlTextReader xtr = new XmlTextReader(uri.ToString(), s);
xtr.XmlResolver = res;
XmlValidatingReader xvr = new XmlValidatingReader(xtr);
xvr.XmlResolver = res;
xvr.ValidationType = ValidationType.None;
Load(new XPathDocument(xvr, XmlSpace.Preserve).CreateNavigator(), resolver
#if NOT_PFX
, null
#endif
);
}
}
public static void Main()
{
// Create the reader.
XmlTextReader reader = new XmlTextReader("http://myServer/data/books.xml");
// Create a secure resolver with default credentials.
XmlUrlResolver resolver = new XmlUrlResolver();
XmlSecureResolver sResolver = new XmlSecureResolver(resolver, "http://myServer/data/");
sResolver.Credentials = CredentialCache.DefaultCredentials;
// Use the secure resolver to resolve resources.
reader.XmlResolver = sResolver;
// Parse the file.
while (reader.Read())
{
// Do any additional processing here.
}
// Close the reader.
reader.Close();
}
static void xsltFormatTransform(string inputPath, string outputPath, string xsltPath)
{
XmlUrlResolver resolver = new XmlUrlResolver();
XsltSettings xsltSettings = new XsltSettings(true, true);
MxmlTextWriter mxmlWriter = mxmlWriter = new MxmlTextWriter(outputPath, null, true);
XmlInput input = new XmlInput(inputPath);
MvpXslTransform mxmlTransform = new MvpXslTransform();
mxmlWriter.Formatting = Formatting.Indented;
mxmlWriter.IndentChar = '\t';
mxmlWriter.Indentation = 1;
mxmlWriter.WriteRaw("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
mxmlWriter.WriteRaw("<?xml-stylesheet type=\"text/xsl\" href=\"../../../material/css/" + BookName + "/" + BookName + ".css\"?>\n");
mxmlWriter.WriteRaw("<!DOCTYPE book SYSTEM \"" + commonSrc + "mxml/dtd/mxml.dtd\">\n");
mxmlTransform.Load(xsltPath, xsltSettings, resolver);
mxmlTransform.Transform(input, null, new XmlOutput(mxmlWriter));
mxmlWriter.Flush();
mxmlWriter.Close();
mxmlWriter = null;
}
public void MatchRootMvpXml()
{
XmlDocument xsltDoc = new XmlDocument();
xsltDoc.LoadXml(@"
<xsl:stylesheet version='1.0'
xmlns:xsl='http://www.w3.org/1999/XSL/Transform'>
<xsl:output method='xml' omit-xml-declaration='no' encoding='UTF-8'/>
<xsl:template match='/'><root>Matched</root></xsl:template>
</xsl:stylesheet>
" );
MvpXslTransform transform = new MvpXslTransform();
var resolver = new XmlUrlResolver();
transform.Load(xsltDoc, XsltSettings.TrustedXslt, resolver);
StringBuilder builder = new StringBuilder();
XmlWriter writer = new XmlTextWriter(new StringWriter(builder));
CollectionOfSimple c = new CollectionOfSimple(true);
ObjectXPathContext context = new ObjectXPathContext();
context.DetectLoops = true;
XPathNavigator nav = context.CreateNavigator(c);
transform.Transform(
new XmlInput(nav, resolver),
null,
new XmlOutput(writer));
writer.Close();
Assert.AreEqual("<root>Matched</root>", builder.ToString());
}
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();
}
protected void Page_Load(object sender, EventArgs e)
{
string xml = Request.QueryString["xml"];
XmlUrlResolver resolver = new XmlUrlResolver();
resolver.Credentials = CredentialCache.DefaultCredentials;
Console.WriteLine(xml);
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.XmlResolver = resolver;
xmlDoc.LoadXml(xml);
XXEResults.Text = string.Empty;
foreach (XmlNode xn in xmlDoc)
{
switch (xn.Name)
{
case "user":
XXEResults.Text = xn.InnerText;
break;
}
}
}
public IActionResult XXE()
{
string xml = RequestUtils.GetIfDefined(Request, "xml");
if (xml.Length <= 0)
{
@ViewData["result"] = "upload your request";
}
else
{
var resolver = new XmlUrlResolver();
resolver.Credentials = CredentialCache.DefaultCredentials;
var xmlDoc = new XmlDocument();
xmlDoc.XmlResolver = resolver;
try
{
xmlDoc.LoadXml(xml);
}
catch (Exception)
{
}
Show("Results of your request: " + string.Empty);
foreach (XmlNode xn in xmlDoc)
{
if (xn.Name == "user")
{
Show("Results of your request: " + _javaScriptEncoder.Encode(xn.InnerText));
}
}
}
return(View());
}
public XsltViewer()
{
this.SetStyle(ControlStyles.ResizeRedraw, true);
this.SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);
InitializeComponent();
stripHeight = this.WebBrowser1.Top;
xslt = new XslCompiledTransform();
settings = new XsltSettings(true, true);
resolver = new XmlUrlResolver();
toolTip1.SetToolTip(this.BrowseButton, SR.BrowseButtonTooltip);
toolTip1.SetToolTip(this.SourceFileName, SR.XslFileNameTooltip);
toolTip1.SetToolTip(this.TransformButton, SR.TransformButtonTooltip);
BrowseButton.Click += new EventHandler(BrowseButton_Click);
this.SourceFileName.KeyDown += new KeyEventHandler(OnSourceFileNameKeyDown);
this.WebBrowser1.ScriptErrorsSuppressed = true;
this.WebBrowser1.WebBrowserShortcutsEnabled = true;
}
/// <summary>
/// Returns a string of the transformed XML
/// </summary>
/// <param name="doc">The document to transform</param>
/// <param name="xslt">The XSLT to use</param>
/// <param name="args">Arguments to pass into the transform</param>
/// <returns>String of transformed XML</returns>
public static string GetTransformedData(IXPathNavigable doc, string xslt, XsltArgumentList args)
{
if (doc == null)
{
return(null);
}
string content = string.Empty;
using (MemoryStream stream = new MemoryStream())
{
XslCompiledTransform transform = new XslCompiledTransform();
XmlUrlResolver resolver = new XmlUrlResolver();
resolver.Credentials = CredentialCache.DefaultCredentials;
XsltSettings settings = new XsltSettings(true, true);
transform.Load(xslt, settings, resolver);
transform.Transform(doc.CreateNavigator(), args, stream);
stream.Position = 0;
StreamReader reader = new StreamReader(stream);
content = reader.ReadToEnd();
}
return(content);
}
public override XmlReaderSettings GetXmlReaderSettings()
{
if (_xmlReaderSettings == null)
{
_xmlReaderSettings = new XmlReaderSettings();
_xmlReaderSettings.ValidationFlags = System.Xml.Schema.XmlSchemaValidationFlags.ProcessIdentityConstraints | System.Xml.Schema.XmlSchemaValidationFlags.ReportValidationWarnings;
MemoryStream xpsSchemaStream = new MemoryStream(XpsS0Schema.S0SchemaBytes);
MemoryStream dictionarySchemaStream = new MemoryStream(XpsS0Schema.DictionarySchemaBytes);
XmlResolver resolver = new XmlUrlResolver();
_xmlReaderSettings.ValidationType = ValidationType.Schema;
_xmlReaderSettings.Schemas.XmlResolver = resolver;
_xmlReaderSettings.Schemas.Add(_xpsS0SchemaNamespace,
new XmlTextReader(xpsSchemaStream));
_xmlReaderSettings.Schemas.Add(null,
new XmlTextReader(dictionarySchemaStream));
}
return(_xmlReaderSettings);
}
/// <summary>
/// Gets the XML document from the specified URL path.
/// </summary>
/// <param name="path">The path where the XML document can be found.</param>
/// <param name="username">The username to use for authentication.</param>
/// <param name="password">The password to use for authentication.</param>
/// <param name="domain">The domain to use for authentication.</param>
/// <returns>Returns the XML document from the specified URL path.</returns>
public static XmlDocument GetXmlDocumentFromUrl(string path, string username, string password, string domain)
{
XmlDocument doc = new XmlDocument();
XmlUrlResolver resolver = new XmlUrlResolver();
if (String.IsNullOrEmpty(username) == false || String.IsNullOrEmpty(password) == false) {
NetworkCredential credential = new NetworkCredential(username, password, domain);
resolver.Credentials = credential;
}
doc.XmlResolver = resolver;
try {
doc.Load(GetAbsoluteUrl(path));
} catch (Exception ex) {
return null;
}
return doc;
}
public void Load (string url, XmlResolver resolver)
{
XmlResolver res = resolver;
if (res == null)
res = new XmlUrlResolver ();
Uri uri = res.ResolveUri (null, url);
using (Stream s = res.GetEntity (uri, null, typeof (Stream)) as Stream) {
XmlTextReader xtr = new XmlTextReader (uri.ToString (), s);
xtr.XmlResolver = res;
XmlValidatingReader xvr = new XmlValidatingReader (xtr);
xvr.XmlResolver = res;
xvr.ValidationType = ValidationType.None;
Load (new XPathDocument (xvr, XmlSpace.Preserve).CreateNavigator (), resolver, null);
}
}
private static XdmNode getSourceRoot(String src)
{
Debug.WriteLine("getting source root node for " + src);
Uri uri = null;
try
{
XmlUrlResolver resolver = new XmlUrlResolver();
uri = resolver.ResolveUri(null, src); //null sets the current location as the resolution base
}
catch (UriFormatException e)
{
Console.WriteLine("error getting transformation source '" + uri + "': " + e.Message);
}
Debug.WriteLine("resolved uri=" + uri.AbsolutePath);
XdmNode doc = null;
try
{
doc = builder.Build(uri);
}
catch (FileNotFoundException e)
{
Console.WriteLine("error getting transformation source: " + e.Message);
}
catch (XPathException e)
{
Console.WriteLine("error getting transformation source: " + e.Message);
}
return doc;
}
/**
* Construct an Environment
*
* @param xpc the XPathCompiler used to process the catalog file
* @param env the Environment element in the catalog file
* @param environments the set of environments to which this one should be added (may be null)
* @return the constructed Environment object
* @throws SaxonApiException
*/
private TestEnvironment processEnvironment(XPathCompiler xpc, XdmItem env, Dictionary<string, TestEnvironment> environments)
{
TestEnvironment environment = new TestEnvironment();
string name = ((XdmNode)env).GetAttributeValue(new QName("name"));
environment.processor = new Processor(true);
XmlUrlResolver res = new XmlUrlResolver();
if (generateByteCode == 1)
{
environment.processor.SetProperty(JFeatureKeys.GENERATE_BYTE_CODE, "true");
environment.processor.SetProperty(JFeatureKeys.DEBUG_BYTE_CODE, "false");
}
else if (generateByteCode == 2)
{
environment.processor.SetProperty(JFeatureKeys.GENERATE_BYTE_CODE, "true");
environment.processor.SetProperty(JFeatureKeys.DEBUG_BYTE_CODE, "true");
}
else
{
environment.processor.SetProperty(JFeatureKeys.GENERATE_BYTE_CODE, "false");
environment.processor.SetProperty(JFeatureKeys.DEBUG_BYTE_CODE, "false");
}
environment.xpathCompiler = environment.processor.NewXPathCompiler();
environment.xpathCompiler.BaseUri = (((XdmNode)env).BaseUri).ToString();
environment.xqueryCompiler = environment.processor.NewXQueryCompiler();
environment.xqueryCompiler.BaseUri = (((XdmNode)env).BaseUri).ToString();
if (unfolded)
{
//environment.xqueryCompiler.getUnderlyingStaticContext().setCodeInjector(new LazyLiteralInjector());
}
DocumentBuilder builder = environment.processor.NewDocumentBuilder();
environment.sourceDocs = new Dictionary<string, XdmNode>();
if (environments != null && name != null)
{
try
{
environments.Add(name, environment);
}catch(Exception e){}
}
System.Collections.IEnumerator dependency = xpc.Evaluate("dependency", env).GetEnumerator();
while (dependency.MoveNext())
{
if (!DependencyIsSatisfied((XdmNode)dependency.Current, environment))
{
environment.usable = false;
}
}
// set the base Uri if specified
IEnumerator base1 = xpc.Evaluate("static-base-uri", env).GetEnumerator();
while (base1.MoveNext())
{
string Uri = ((XdmNode)base1.Current).GetAttributeValue(new QName("uri"));
try
{
environment.xpathCompiler.BaseUri = Uri;
environment.xqueryCompiler.BaseUri = Uri;
}
catch (Exception e)
{
Console.WriteLine("**** invalid base Uri " + Uri);
}
}
// set any requested collations
base1 = xpc.Evaluate("collation", env).GetEnumerator();
while (base1.MoveNext())
{
string uriStr = ((XdmNode)base1.Current).GetAttributeValue(new QName("uri"));
string defaultAtt = ((XdmNode)base1.Current).GetAttributeValue(new QName("default"));
Boolean defaultCol = false;
if (defaultAtt != null && (defaultAtt.Trim().Equals("true") || defaultAtt.Trim().Equals("1")))
{
defaultCol = true;
}
if (uriStr.Equals("http://www.w3.org/2010/09/qt-fots-catalog/collation/caseblind"))
{
net.sf.saxon.Configuration config = xpc.Processor.Implementation;
net.sf.saxon.lib.StringCollator collator = config.getCollationURIResolver().resolve("http://saxon.sf.net/collation?ignore-case=yes", "", config);
CompareInfo compareInfo = CultureInfo.CurrentCulture.CompareInfo;
CompareOptions options = CompareOptions.IgnoreCase;
environment.xpathCompiler.DeclareCollation(new Uri(uriStr), compareInfo, options, defaultCol);
environment.xqueryCompiler.DeclareCollation(new Uri(uriStr), compareInfo, options, defaultCol);
}
}
// declare the requested namespaces
IEnumerator nsElement = xpc.Evaluate("namespace", env).GetEnumerator();
while (nsElement.MoveNext())
{
string prefix = ((XdmNode)nsElement.Current).GetAttributeValue(new QName("prefix"));
string uri = ((XdmNode)nsElement.Current).GetAttributeValue(new QName("uri"));
environment.xpathCompiler.DeclareNamespace(prefix, uri);
environment.xqueryCompiler.DeclareNamespace(prefix, uri);
}
// load the requested schema documents
SchemaManager manager = environment.processor.SchemaManager;
System.Collections.IEnumerator schema = xpc.Evaluate("schema", env).GetEnumerator();
while (schema.MoveNext())
{
string href = ((XdmNode)schema.Current).GetAttributeValue(new QName("file"));
manager.Compile((new Uri(((XdmNode)env).BaseUri, href)));
}
// load the requested source documents
//IEnumerator source = xpc.Evaluate("source", env).GetEnumerator();
foreach (XdmItem source in xpc.Evaluate("source", env))
{
Uri href = res.ResolveUri(((XdmNode)env).BaseUri, ((XdmNode)source).GetAttributeValue(new QName("file")));
string Uri = ((XdmNode)source).GetAttributeValue(new QName("uri"));
string validation = ((XdmNode)source).GetAttributeValue(new QName("", "validation"));
XdmNode doc = null;
if (validation == null || validation.Equals("skip"))
{
try
{
doc = builder.Build(href);
}
catch (Exception e)
{
feedback.Message("Error:" + e.Message+" *** failed to build source document " + href, false);
}
}
else
{
try
{
SchemaValidator validator = manager.NewSchemaValidator();
XdmDestination xdmDest = new XdmDestination();
validator.IsLax = validation.Equals("lax");
validator.SetDestination(xdmDest);
validator.SetSource(href);
validator.Run();
doc = xdmDest.XdmNode;
environment.xpathCompiler.SchemaAware = true;
environment.xqueryCompiler.SchemaAware = true;
}
catch(Exception e) {
feedback.Message("Error:" + e.Message+" *** failed to build source document " + href, false);
}
}
if (Uri != null)
{
environment.sourceDocs.Add(Uri, doc);
}
string role = ((XdmNode)source).GetAttributeValue(new QName("role"));
if (role != null)
{
if (".".Equals(role))
{
environment.contextNode = doc;
}
else if (role.StartsWith("$"))
{
string varName = role.Substring(1);
environment.params1.Add(new QName(varName), doc);
environment.xpathCompiler.DeclareVariable(new QName(varName));
environment.paramDeclarations.Append("declare variable $" + varName + " external; ");
}
}
}
// create a collection Uri resolved to handle the requested collections
Hashtable collections = new Hashtable();
foreach (XdmItem coll in xpc.Evaluate("collection", env))
{
string collectionUri = ((XdmNode)coll).GetAttributeValue(new QName("uri"));
if (collectionUri == null || collectionUri.Equals(""))
{
collectionUri = "http://www.saxonica.com/defaultCollection";
}
IList<Uri> docs = new List<Uri>();
foreach (XdmItem source in xpc.Evaluate("source", coll))
{
Uri href = res.ResolveUri(((XdmNode)env).BaseUri, ((XdmNode)source).GetAttributeValue(new QName("file")));
//File file = new File((((XdmNode) env).GetBaseUri().resolve(href)));
string id = ((XdmNode)source).GetAttributeValue(new QName(JNamespaceConstant.XML, "id"));
XdmNode doc = builder.Build(href);
if (id != null)
{
environment.sourceDocs.Add(id, doc);
}
environment.processor.RegisterCollection(href, getCollection(doc, href.AbsoluteUri));
environment.sourceDocs.Add(href.ToString(), doc);
docs.Add(doc.DocumentUri);
}
try {
collections.Add(new Uri(collectionUri), docs);
} catch (Exception e) {
feedback.Message("**** Invalid collection Uri " + collectionUri, false);
}
}
if (collections.Count != 0) {
environment.processor.Implementation.setCollectionURIResolver(new CollectionResolver(collections));
/* new net.sf.saxon.lib.CollectionURIResolver() {
public SequenceIterator resolve(string href, string base, XPathContext context) {
try {
List<AnyUriValue> docs;
if (href == null) {
docs = collections.get(new Uri(""));
} else {
Uri abs = new Uri(base).resolve(href);
docs = collections.get(abs);
}
if (docs == null) {
return EmptyIterator.getInstance();
} else {
return new ListIterator(docs);
}
} catch (UriSyntaxException e) {
Console.WriteLine("** Invalid Uri: " + e.Message);
return EmptyIterator.getInstance();
}
}
}
)*/
}
// register any required decimal formats
IEnumerator decimalFormat = xpc.Evaluate("decimal-format", env).GetEnumerator();
while (decimalFormat.MoveNext())
{
XdmNode formatElement = (XdmNode) decimalFormat.Current;
string formatName = formatElement.GetAttributeValue(new QName("name"));
QName formatQName = null;
if (formatName != null) {
if (formatName.IndexOf(':') < 0) {
formatQName = new QName("", "", formatName);
} else {
try {
formatQName = new QName(environment.xpathCompiler.GetNamespaceURI(formatName, false), formatName.Substring(formatName.IndexOf(':')+1));
} catch (Exception) {
feedback.Message("**** Invalid QName as decimal-format name", false);
formatQName = new QName("", "", "error-name");
}
}
environment.paramDecimalDeclarations.Append("declare decimal-format " + formatName + " ");
} else {
environment.paramDecimalDeclarations.Append("declare default decimal-format ");
}
foreach (XdmItem decimalFormatAtt in xpc.Evaluate("@* except @name", formatElement)) {
XdmNode formatAttribute = (XdmNode) decimalFormatAtt;
string property = formatAttribute.NodeName.LocalName;
string value = formatAttribute.StringValue;
environment.paramDecimalDeclarations.Append(property + "=\"" + value + "\" ");
environment.xpathCompiler.SetDecimalFormatProperty(formatQName, property, value);
}
environment.paramDecimalDeclarations.Append(";");
}
// declare any variables
IEnumerator param = xpc.Evaluate("param", env).GetEnumerator();
while (param.MoveNext())
{
string varName = ((XdmNode)param.Current).GetAttributeValue(new QName("name"));
XdmValue value = null;
string sourceStr = ((XdmNode)param.Current).GetAttributeValue(new QName("source"));
if (sourceStr != null)
{
XdmNode sourceDoc = (XdmNode)(environment.sourceDocs[sourceStr]);
if (sourceDoc == null)
{
Console.WriteLine("**** Unknown source document " + sourceDoc.ToString());
}
value = sourceDoc;
}
else
{
string select = ((XdmNode)param.Current).GetAttributeValue(new QName("select"));
value = xpc.Evaluate(select, null);
}
environment.params1.Add(new QName(varName), value);
environment.xpathCompiler.DeclareVariable(new QName(varName));
string declared = ((XdmNode)param.Current).GetAttributeValue(new QName("declared"));
if (declared != null && "true".Equals(declared) || "1".Equals(declared))
{
// no action
}
else
{
environment.paramDeclarations.Append("declare variable $" + varName + " external; ");
}
}
return environment;
}
static TextReader GetReader (string filename)
{
XmlResolver resolver = new XmlUrlResolver ();
Stream stream = resolver.GetEntity (resolver.ResolveUri (null, filename), null, typeof (Stream)) as Stream;
if (useDecentReader)
return new XmlSignatureStreamReader (
new StreamReader (stream));
else
return new StreamReader (stream);
}
private XmlReader GetXmlReader (string url)
{
XmlResolver res = new XmlUrlResolver ();
Uri uri = res.ResolveUri (null, url);
Stream s = res.GetEntity (uri, null, typeof (Stream)) as Stream;
XmlTextReader xtr = new XmlTextReader (uri.ToString (), s);
xtr.XmlResolver = res;
XmlValidatingReader xvr = new XmlValidatingReader (xtr);
xvr.XmlResolver = res;
xvr.ValidationType = ValidationType.None;
return xvr;
}
private bool LoadSchema(string uri) {
uri = _NameTable.Add(uri);
if (_SchemaInfo.HasSchema(uri)) {
return false;
}
SchemaInfo schemaInfo = null;
XmlResolver resolver = new XmlUrlResolver();
Uri _baseUri = resolver.ResolveUri(null,_reader.BaseURI);
XmlReader reader = null;
try {
Uri ruri = resolver.ResolveUri(_baseUri, uri.Substring(x_schema.Length));
Stream stm = (Stream)resolver.GetEntity(ruri,null,null);
reader = new XmlTextReader(ruri.ToString(), stm, _NameTable);
schemaInfo = new SchemaInfo(_SchemaNames);
new Parser(null, _NameTable, _SchemaNames, validationEventHandler).Parse(reader, uri, schemaInfo);
}
catch(XmlException e) {
SendValidationEvent(Res.Sch_CannotLoadSchema, new string[] {uri, e.Message}, XmlSeverityType.Warning);
schemaInfo = null;
}
finally {
if (reader != null) {
reader.Close();
}
}
if (schemaInfo != null && schemaInfo.ErrorCount == 0) {
_SchemaInfo.Add(uri, schemaInfo, validationEventHandler);
return true;
}
return false;
}
public void TransformXml(string[] parts)
{
XsltSettings XSLSettings = new XsltSettings();
XSLSettings.EnableDocumentFunction = true;
XmlUrlResolver resolver = new XmlUrlResolver();
XslCompiledTransform xsl = new XslCompiledTransform();
xsl.Load(root + "/templates/global.xsl", XSLSettings, resolver);
timmie.timmie timmie = new timmie.timmie();
XsltArgumentList args = new XsltArgumentList();
args.AddExtensionObject(timmie.nameSpaceURI, timmie);
xsl.Transform(CreateContext(parts), args, HttpContext.Current.Response.Output);
}
public ModuleResolver(XPathCompiler xpc)
{
this.catXPC = xpc;
resolver = new XmlUrlResolver();
}
private XmlReader validateRequest(Stream inputStream)
{
//load instance into memory
XmlReaderSettings settings = new XmlReaderSettings();
settings.Schemas.Add(null, Server.MapPath(".") + "\\wsrequest.xsd");
//add resolver to pass security if accessing web site to recieve schemaXmlUrlResolver
XmlUrlResolver resolver = new XmlUrlResolver();
resolver.Credentials = System.Net.CredentialCache.DefaultCredentials;
settings.XmlResolver = resolver;
settings.ValidationType = ValidationType.Schema; //this line is neccessary for validation to
settings.ValidationEventHandler += new ValidationEventHandler(xvr_ValidationEventHandler);
return XmlReader.Create(inputStream, settings);
}
public net.sf.saxon.om.SequenceIterator resolve(string href, string baseStr, net.sf.saxon.expr.XPathContext context) {
try {
List<Uri> docs;
if (href == null) {
docs = (List<Uri>)collections[new Uri("http://www.saxonica.com/defaultCollection")];
} else {
XmlUrlResolver res = new XmlUrlResolver();
Uri abs= res.ResolveUri(new Uri(baseStr), href);
docs = (List<Uri>)collections[abs];
}
if (docs == null) {
return net.sf.saxon.tree.iter.EmptyIterator.getInstance();
} else {
java.util.List list = new java.util.ArrayList();
foreach(Uri uri in docs){
list.add(new net.sf.saxon.value.AnyURIValue(uri.ToString()));
}
return new net.sf.saxon.tree.iter.ListIterator(list);
}
} catch (java.net.URISyntaxException e) {
Console.WriteLine("** Invalid Uri: " + e.Message);
return net.sf.saxon.tree.iter.EmptyIterator.getInstance();
}
}
//Public Methods
/// <include file='doc\XmlSchemaSet.uex' path='docs/doc[@for="XmlSchemaSet.Add1"]/*' />
/// <devdoc>
/// <para>Add the schema located by the given URL into the schema schemas.
/// If the given schema references other namespaces, the schemas for those other
/// namespaces are NOT automatically loaded.</para>
/// </devdoc>
public XmlSchema Add(String targetNamespace, String schemaUri) {
if (schemaUri == null || schemaUri.Length == 0) {
throw new ArgumentNullException("schemaUri");
}
if (targetNamespace != null) {
targetNamespace = XmlComplianceUtil.CDataNormalize(targetNamespace);
}
XmlSchema schema = null;
lock (InternalSyncObject) {
//Check if schema from url has already been added
XmlResolver tempResolver = readerSettings.GetXmlResolver();
if ( tempResolver == null ) {
tempResolver = new XmlUrlResolver();
}
Uri tempSchemaUri = tempResolver.ResolveUri(null, schemaUri);
if (IsSchemaLoaded(tempSchemaUri, targetNamespace, out schema)) {
return schema;
}
else {
//Url already not processed; Load SOM from url
XmlReader reader = XmlReader.Create(schemaUri, readerSettings);
try {
schema = Add(targetNamespace, ParseSchema(targetNamespace, reader)); //TODO can move parsing outside lock boundary
while(reader.Read());// wellformness check;
}
finally {
reader.Close();
}
}
}
return schema;
}
