// Constructor.
public XmlDTDReader(XmlParserContext context)
: base(null)
{
this.context = context;
this.input = null;
this.resolver = null;
}
/// <summary>
/// Returns the dataset loaded from the given document data.
/// </summary>
/// <param name="documentData">Document data to make the dataset from</param>
/// <param name="taskType">Task type</param>
/// <param name="taskObjectType">Task object type</param>
protected virtual DataSet GetDataSet(string documentData, TaskTypeEnum taskType, string taskObjectType)
{
SyncHelper syncHelper = SyncHelper.GetInstance();
syncHelper.OperationType = OperationTypeEnum.Synchronization;
string className = CMSHierarchyHelper.GetNodeClassName(documentData, ExportFormatEnum.XML);
DataSet ds = syncHelper.GetSynchronizationTaskDataSet(taskType, className, taskObjectType);
XmlParserContext xmlContext = new XmlParserContext(null, null, null, XmlSpace.None);
XmlReader reader = new XmlTextReader(documentData, XmlNodeType.Element, xmlContext);
return DataHelper.ReadDataSetFromXml(ds, reader, null, null);
}
private void ProcessQueue()
{
const string endStream = "</stream:stream>";
while (true)
{
if (_xmpp.State is DisconnectedState || !_running)
{
_logger.Log(LogLevel.Debug, "Disconnected or stopped");
break;
}
if (_dataQueue.Count <= 0)
{
continue;
}
var message = _dataQueue.Dequeue();
if (message.Contains(endStream))
{
_logger.Log(LogLevel.Debug, "Ending stream and disconnecting");
_xmpp.State = new DisconnectState();
_xmpp.State.Execute(_xmpp);
if (message.Equals(endStream))
{
return;
}
message = message.Replace(endStream, string.Empty);
}
if (message.Contains("<stream:stream") && !message.Contains(endStream))
{
_logger.Log(LogLevel.Debug, "Adding end tag");
message += endStream;
}
var context = new XmlParserContext(null, NamespaceManager, null, XmlSpace.None);
var reader = new XmlTextReader(message, XmlNodeType.Element, context);
var root = XElement.Load(reader);
var tag = _xmpp.Registry.GetTag <Tag>(root);
_logger.Log(LogLevel.Debug, $"Found tag {tag}");
OnTag(tag);
}
}
/// <summary>
/// Returns the dataset loaded from the given document data.
/// </summary>
/// <param name="documentData">Document data to make the dataset from</param>
/// <param name="taskType">Task type</param>
/// <param name="taskObjectType">Task object type</param>
protected virtual DataSet GetDataSet(string documentData, TaskTypeEnum taskType, string taskObjectType)
{
var man = SyncManager.GetInstance();
man.OperationType = OperationTypeEnum.Synchronization;
string className = DocumentHierarchyHelper.GetNodeClassName(documentData, ExportFormatEnum.XML);
DataSet ds = man.GetSynchronizationTaskDataSet(taskType, className, taskObjectType);
XmlParserContext xmlContext = new XmlParserContext(null, null, null, XmlSpace.None);
XmlReader reader = new XmlTextReader(documentData, XmlNodeType.Element, xmlContext);
return(DataHelper.ReadDataSetFromXml(ds, reader, null, null));
}
public EntityResolvingXmlReader(XmlReader source)
{
this.source = source;
IHasXmlParserContext container = source as IHasXmlParserContext;
if (container != null)
{
this.context = container.ParserContext;
}
else
{
this.context = new XmlParserContext(source.NameTable, new XmlNamespaceManager(source.NameTable), null, XmlSpace.None);
}
}
public void DublinCoreElementSet_LoadTest()
{
DublinCoreElementSetSyndicationExtension target = new DublinCoreElementSetSyndicationExtension(); // TODO: Initialize to an appropriate value
var nt = new NameTable();
var ns = new XmlNamespaceManager(nt);
var xpc = new XmlParserContext(nt, ns, "US-en", XmlSpace.Default);
var strXml = ExtensionTestUtil.GetWrappedXml(namespc, strExtXml);
using (XmlReader reader = new XmlTextReader(strXml, XmlNodeType.Document, xpc))
{
RssFeed feed = new RssFeed();
feed.Load(reader);
}
}
public clsCTCheckOrderDomain()
{
//
// TODO: Add constructor logic here
//
m_objXmlMemStream = new MemoryStream(300);
m_objXmlWriter = new XmlTextWriter(m_objXmlMemStream, System.Text.Encoding.Unicode);
m_objXmlWriter.Flush(); //賠腎圻栖議忖憲
m_objXmlParser = new XmlParserContext(null, null, null, XmlSpace.None, Encoding.Unicode);
//m_objServ =new com.digitalwave.CTCheckOrderServ.clsCTCheckOrderServ();
}
public static void Main()
{
XmlTextReader reader = null;
try
{
//Create the XML fragment to be parsed.
string xmlFrag = "<book> " +
"<title>Pride And Prejudice</title>" +
"<bk:genre>novel</bk:genre>" +
"</book>";
//Create the XmlNamespaceManager that is used to
//look up namespace information.
NameTable nt = new NameTable();
XmlNamespaceManager nsmgr = new XmlNamespaceManager(nt);
nsmgr.AddNamespace("bk", "urn:sample");
//Create the XmlParserContext.
XmlParserContext context = new XmlParserContext(null, nsmgr, null, XmlSpace.None);
//Implement the reader.
reader = new XmlTextReader(xmlFrag, XmlNodeType.Element, context);
//Parse the XML fragment. If they exist, display the
//prefix and namespace URI of each element.
while (reader.Read())
{
if (reader.IsStartElement())
{
if (reader.Prefix == String.Empty)
Console.WriteLine("<{0}>", reader.LocalName);
else
{
Console.Write("<{0}:{1}>", reader.Prefix, reader.LocalName);
Console.WriteLine(" The namespace URI is " + reader.NamespaceURI);
}
}
}
}
finally
{
if (reader != null)
reader.Close();
}
}
static async Task copyStreamWithInterrupt(Process coqtop, Stream from, Stream to)
{
try
{
var settings = new XmlReaderSettings();
settings.Async = true;
settings.CheckCharacters = false;
settings.ValidationType = ValidationType.None;
settings.ConformanceLevel = ConformanceLevel.Fragment;
settings.DtdProcessing = DtdProcessing.Parse;
var context = new XmlParserContext(null, new XmlNamespaceManager(new NameTable()), null, XmlSpace.None, Encoding.UTF8);
context.InternalSubset = "<!ENTITY nbsp \" \">";
context.DocTypeName = "coq";
var reader = XmlTextReader.Create(from, settings, context);
var writer = new StreamWriter(to);
while (await reader.ReadAsync())
{
if (reader.NodeType == XmlNodeType.Element && reader.Depth == 0 && reader.Name == "call" && reader.GetAttribute("val") == "Interrupt")
{
await Console.Error.WriteLineAsync("Sending ctrl+break");
Signals.SendCtrlBreak(coqtop.Id);
using (var y = reader.ReadSubtree())
{
y.Read();
await y.ReadOuterXmlAsync();
}
//await reader.SkipAsync();
}
else if (reader.NodeType == XmlNodeType.Element)
{
using (var y = reader.ReadSubtree())
{
y.Read();
await writer.WriteAsync(await y.ReadOuterXmlAsync());
await writer.FlushAsync();
}
}
}
}
catch (Exception error)
{
Console.Error.WriteLine("Error reading main channel write stream.");
Console.Error.WriteLine("Reason: " + error.ToString());
System.Environment.Exit(-1);
}
}
/// <summary>
/// Load oar control file
/// </summary>
/// <param name="path"></param>
/// <param name="data"></param>
protected void LoadControlFile(string path, byte[] data)
{
XmlNamespaceManager nsmgr = new XmlNamespaceManager(new NameTable());
XmlParserContext context = new XmlParserContext(null, nsmgr, null, XmlSpace.None);
XmlTextReader xtr = new XmlTextReader(Encoding.ASCII.GetString(data), XmlNodeType.Document, context);
RegionSettings currentRegionSettings = m_scene.RegionInfo.RegionSettings;
// Loaded metadata will empty if no information exists in the archive
currentRegionSettings.LoadedCreationDateTime = 0;
currentRegionSettings.LoadedCreationID = "";
while (xtr.Read())
{
if (xtr.NodeType == XmlNodeType.Element)
{
if (xtr.Name.ToString() == "archive")
{
int majorVersion = int.Parse(xtr["major_version"]);
int minorVersion = int.Parse(xtr["minor_version"]);
string version = string.Format("{0}.{1}", majorVersion, minorVersion);
if (majorVersion > MAX_MAJOR_VERSION)
{
throw new Exception(
string.Format(
"The OAR you are trying to load has major version number of {0} but this version of OpenSim can only load OARs with major version number {1} and below",
majorVersion, MAX_MAJOR_VERSION));
}
m_log.InfoFormat("[ARCHIVER]: Loading OAR with version {0}", version);
}
if (xtr.Name.ToString() == "datetime")
{
int value;
if (Int32.TryParse(xtr.ReadElementContentAsString(), out value))
{
currentRegionSettings.LoadedCreationDateTime = value;
}
}
else if (xtr.Name.ToString() == "id")
{
currentRegionSettings.LoadedCreationID = xtr.ReadElementContentAsString();
}
}
}
currentRegionSettings.Save();
}
public CoqtopXmlReader(StreamReader source)
{
var settings = new XmlReaderSettings();
settings.Async = true;
settings.CheckCharacters = false;
settings.ValidationType = ValidationType.None;
settings.ConformanceLevel = ConformanceLevel.Fragment;
settings.DtdProcessing = DtdProcessing.Parse;
var context = new XmlParserContext(null, new XmlNamespaceManager(new NameTable()), null, XmlSpace.None, Encoding.UTF8);
context.InternalSubset = "<!ENTITY nbsp \" \">";
context.DocTypeName = "coq";
this.reader = XmlTextReader.Create(source, settings, context);
}
} // func GetXmlStreamAsync
public XmlReader GetXmlStreamAsync(WebResponse response, string acceptedMimeType = MimeTypes.Text.Xml, XmlReaderSettings settings = null)
{
if (settings == null)
{
settings = new XmlReaderSettings();
settings.IgnoreComments = acceptedMimeType != MimeTypes.Application.Xaml;
settings.IgnoreWhitespace = acceptedMimeType != MimeTypes.Application.Xaml;
}
settings.CloseInput = true;
var baseUri = response.ResponseUri.GetComponents(UriComponents.Scheme | UriComponents.Host | UriComponents.Port | UriComponents.Path, UriFormat.SafeUnescaped);
var context = new XmlParserContext(null, null, null, null, null, null, baseUri, null, XmlSpace.Default);
return(XmlReader.Create(GetTextReaderAsync(response, acceptedMimeType), settings, context));
} // func GetXmlStreamAsync
private static XmlReader CreateXmlReader(Stream stream)
{
XmlNamespaceManager namespaceManager = new XmlNamespaceManager(new NameTable());
namespaceManager.AddNamespace("v", "http://www.eki.ee/dict/evs");
XmlParserContext context = new XmlParserContext(null, namespaceManager, null, XmlSpace.None);
XmlReaderSettings readerSettings = new XmlReaderSettings
{
ConformanceLevel = ConformanceLevel.Fragment
};
return(XmlReader.Create(stream, readerSettings, context));
}
/// <summary>
///
/// </summary>
/// <param name="component">Associated editor</param>
private EdxDocument(XmlControl component)
{
this.editor = component.HtmlEditor;
this.nativeRootControl = component;
//prepare the validating reader for accepting HTML characters
xhtmlContext = Util.CreateXhtmlContext();
xs = new XmlReaderSettings();
xs.ProhibitDtd = false;
xs.ValidationType = ValidationType.None;
xs.XmlResolver = Util.CreateXhtmlResolver();
// Namespace resolver
xmlnsEdx = Util.CreateEdxNamespaceManager();
fo = new HtmlFormatterOptions(' ', 1, 1024, true);
formatter = new HtmlFormatter();
}
/// <summary>
/// Creates the validating XML reader.
/// </summary>
/// <param name="uri">The URI.</param>
/// <param name="stream">The stream.</param>
/// <returns></returns>
private XmlReader CreateValidatingXmlReader(string uri, Stream stream)
{
//return new XmlTextReader(uri, stream);
XmlReaderSettings xmlReaderSettings = GetXmlReaderSettings();
if (string.IsNullOrWhiteSpace(uri))
{
return(XmlReader.Create(stream, xmlReaderSettings, uri));
}
else
{
XmlParserContext xmlParserContext = GetXmlParserContext();
return(XmlReader.Create(stream, xmlReaderSettings, xmlParserContext));
}
}
private static XmlNode getXmlNodeFromString(String str, XmlDocument dest)
{
XmlNode result = null;
//Костыль, позволяющий избежать ошибки необъявленного нэймспейса xs в открываемых паттернах
XmlNamespaceManager mgr = new XmlNamespaceManager(new NameTable());
mgr.AddNamespace("xs", "http://www.w3.org/2001/XMLSchema");
XmlParserContext ctx = new XmlParserContext(null, mgr, null, XmlSpace.Default);
using (XmlReader reader = XmlReader.Create(new StringReader(str), null, ctx))
{
result = dest.ReadNode(reader);
}
return(result);
}
public ILogEventParserInstance Begin(Stream stream)
{
//
// a trick to handle multiple-root xml streams
// as described by Oleg Tkachenko in his blog:
//
// http://www.tkachenko.com/blog/archives/000053.html
//
XmlParserContext context = new XmlParserContext(new NameTable(), null, null, XmlSpace.Default);
XmlTextReader xtr = new XmlTextReader(stream, XmlNodeType.Element, context);
xtr.Namespaces = false;
return(new Context(xtr));
}
/// <summary>
/// Получить содержимое блока в виде xml.
/// </summary>
/// <param name="blockName">Имя блока.</param>
/// <returns>Содержимым блока.</returns>
public XElement GetXmlBlockContent(string blockName)
{
var content = this.GetBlockContent(blockName);
if (string.IsNullOrEmpty(content))
{
return(null);
}
var namespaceManager = new XmlNamespaceManager(new NameTable());
var parserContext = new XmlParserContext(null, namespaceManager, null, XmlSpace.Preserve);
using (var xmlReader = new XmlTextReader(content, XmlNodeType.Element, parserContext))
return(XElement.Load(xmlReader));
}
public static Node FromXmlFragment(string xml, IssueSink sink)
{
NameTable nt = new NameTable();
XmlNamespaceManager nsmanager = new XmlNamespaceManager(nt);
XmlParserContext context =
new XmlParserContext(nt, nsmanager, "elem", XmlSpace.None, System.Text.Encoding.UTF8);
XmlTextReader reader = new XmlTextReader(xml, XmlNodeType.Element, context);
Node n = new Node(new XmlDocument().ReadNode(reader) as XmlElement, sink);
reader.Close();
return(n);
}
/// <summary>
/// Static constructior to initialize the Log4J XML parser context.
/// </summary>
static LogMessageLog4Net()
{
XmlNamespaceManager namespaceManager =
new XmlNamespaceManager(new NameTable());
namespaceManager.AddNamespace(
"log4j"
, "http://jakarta.apache.org/log4j/");
mParserContext = new XmlParserContext(
null
, namespaceManager
, null
, XmlSpace.Default);
}
public static XDocument ParseDocument(string diagramXml)
{
XmlNamespaceManager nmgr = new XmlNamespaceManager(new NameTable());
nmgr.AddNamespace("xsi", WorkflowBuilder.xsi.NamespaceName);
nmgr.AddNamespace("bpmn", WorkflowBuilder.bpmn.NamespaceName);
nmgr.AddNamespace("bpmndi", WorkflowBuilder.bpmndi.NamespaceName);
nmgr.AddNamespace("dc", WorkflowBuilder.dc.NamespaceName);
nmgr.AddNamespace("di", WorkflowBuilder.di.NamespaceName);
XmlParserContext pctx = new XmlParserContext(null, nmgr, null, XmlSpace.None);
XmlTextReader reader = new XmlTextReader(diagramXml, XmlNodeType.Document, pctx);
return(XDocument.Load(reader));
}
public XmlReaderBodyWriter(string xml, int maxBufferSize, XmlParserContext ctx)
: base(true)
{
var settings = new XmlReaderSettings()
{
// FIXME: enable this line (once MaxCharactersInDocument is implemented)
// MaxCharactersInDocument = maxBufferSize,
ConformanceLevel = ConformanceLevel.Fragment
};
reader = XmlDictionaryReader.CreateDictionaryReader(XmlReader.Create(new StringReader(xml), settings, ctx));
reader.MoveToContent();
xml_bak = xml;
parser_context = ctx;
}
private async Task <SpatialDataSet> ParseGPX(Stream gpxStream)
{
var nt = new NameTable();
var nsmgr = new XmlNamespaceManager(nt);
nsmgr.AddNamespace("gpxx", GpxxNamespace);
var pc = new XmlParserContext(null, nsmgr, null, XmlSpace.None);
using (var reader = XmlReader.Create(gpxStream, null, pc))
{
var doc = XDocument.Load(reader);
return(await ParseGPX(doc, string.Empty));
}
}
private bool Populate(string data)
{
XElement element;
int lineNumber;
if (!_validQueryHeader.IsMatch(data))
{
return(false);
}
try
{
XmlParserContext context = new XmlParserContext(null, null, null, XmlSpace.None);
Stream xmlFragment = new MemoryStream(Encoding.UTF8.GetBytes(data));
XmlTextReader reader = new XmlTextReader(xmlFragment, XmlNodeType.Element, context);
reader.MoveToContent();
XmlReader reader2 = reader.ReadSubtree();
StringBuilder output = new StringBuilder();
using (XmlWriter writer = XmlWriter.Create(output))
{
writer.WriteNode(reader2, true);
}
element = XElement.Parse(output.ToString());
lineNumber = reader.LineNumber;
}
catch (XmlException)
{
return(false);
}
if (element.Attribute("Kind") != null)
{
try
{
this._language = (QueryLanguage)Enum.Parse(typeof(QueryLanguage), (string)element.Attribute("Kind"), true);
}
catch (ArgumentException)
{
}
}
this._metaData = element;
StringReader reader3 = new StringReader(data);
for (int i = 0; i < lineNumber; i++)
{
reader3.ReadLine();
}
this._text = reader3.ReadToEnd().Trim();
return(true);
}
public static string LimitHtmlOnWordBoundary(this string str, int maxLength, string ellipses = "...")
{
XmlDocument doc = new XmlDocument();
XmlParserContext context = new XmlParserContext(doc.NameTable, new XmlNamespaceManager(doc.NameTable), null, XmlSpace.Preserve);
XmlTextReader reader = new XmlTextReader("<xml>" + str + "</xml>", XmlNodeType.Document, context);
bool shouldWriteEllipses;
using (var writer = doc.CreateNavigator().AppendChild())
{
LimitHtmlOnWordBoundary(writer, reader, maxLength, out shouldWriteEllipses);
writer.Flush();
}
return(doc.DocumentElement.InnerXml + (shouldWriteEllipses ? ellipses : ""));
}
public void Parse3()
{
XmlNamespaceManager nsMgr = new MyNS(XmlReader.Create(new StringReader(empty)));
XmlParserContext inputContext = new XmlParserContext(null, nsMgr, null, XmlSpace.None);
XmlReader xr = XmlReader.Create(new StringReader(xmlstr), new XmlReaderSettings(), inputContext);
XmlNamespaceManager aMgr = new MyNS(xr);
XmlParserContext inputContext2 = new XmlParserContext(null, aMgr, null, XmlSpace.None);
XmlReader xr2 = XmlReader.Create(new StringReader(xmlstr2), new XmlReaderSettings(), inputContext2);
Assert.Throws <XmlException> (delegate {
while (xr2.Read())
{
}
}, "null");
}
public void Parse2()
{
XmlNamespaceManager nsMgr = new MyNS(XmlReader.Create(new StringReader(empty)));
nsMgr.AddNamespace("foo", "bar");
XmlParserContext inputContext = new XmlParserContext(null, nsMgr, null, XmlSpace.None);
XmlReader xr = XmlReader.Create(new StringReader(xmlstr), new XmlReaderSettings(), inputContext);
XmlNamespaceManager aMgr = new MyNS(xr);
XmlParserContext inputContext2 = new XmlParserContext(null, aMgr, null, XmlSpace.None);
XmlReader xr2 = XmlReader.Create(new StringReader(xmlstr2), new XmlReaderSettings(), inputContext2);
while (xr2.Read())
{
}
}
private string NfeDadosMsg(string sJust)
{
XmlSchemaCollection myschema = new XmlSchemaCollection();
XmlValidatingReader reader;
try
{
DataTable dt = BuscaProtocoloNFe(objPesquisa.sCD_NFSEQ);
XNamespace xname = "http://www.portalfiscal.inf.br/nfe";
XDocument xdoc = new XDocument(new XElement(xname + "cancNFe", new XAttribute("versao", Acesso.versaoNFe),
new XElement(xname + "infCanc", new XAttribute("Id", "ID" + objPesquisa.sCHAVENFE),
new XElement(xname + "tpAmb", Acesso.TP_AMB),
new XElement(xname + "xServ", "CANCELAR"),
new XElement(xname + "chNFe", objPesquisa.sCHAVENFE),
new XElement(xname + "nProt", dt.Rows[0]["cd_nprotnfe"].ToString()),
new XElement(xname + "xJust", sJust))));
string sPath = Pastas.PROTOCOLOS + "\\" + objPesquisa.sCD_NFSEQ + "_ped-can.xml";
xdoc.Save(sPath);
belAssinaXml assinaCanc = new belAssinaXml();
string sArquivoAssinado = assinaCanc.ConfigurarArquivo(sPath, "infCanc", Acesso.cert_NFe);
StreamReader ler;
ler = File.OpenText(sPath);
XmlParserContext context = new XmlParserContext(null, null, "", XmlSpace.None);
reader = new XmlValidatingReader(ler.ReadToEnd().ToString(), XmlNodeType.Element, context);
myschema.Add("http://www.portalfiscal.inf.br/nfe", Pastas.SCHEMA_NFE + "\\cancNFe_v2.00.xsd");
reader.ValidationType = ValidationType.Schema;
reader.Schemas.Add(myschema);
while (reader.Read())
{
}
return(sArquivoAssinado);
}
catch (Exception x)
{
throw new Exception(x.Message);
}
}
/// <summary>
/// Checks the update via RSS.
/// </summary>
/// <param name="uri">The URI.</param>
private void CheckUpdateViaRss(Uri uri)
{
_updateList = new UpdateInfoList();
XmlDocument doc = new XmlDocument();
try {
Stream strm = GetRssStream(uri);
using ( strm ) {
doc.Load(strm);
}
} catch { throw; }
XmlNamespaceManager nsm = CreateXmlNamespaceManager(doc);
XmlNodeList updateInfoNodes = doc.SelectNodes(string.Format(Properties.Strings.UpdateInfoRootXPath, Properties.Strings.UpdateInfoNamespacePrefix), nsm);
// Console.WriteLine ( "{0} Update info items found", updateInfoNodes.Count );
foreach (XmlElement uie in updateInfoNodes)
{
try {
XmlParserContext xpc = new XmlParserContext(doc.NameTable, nsm, string.Empty, XmlSpace.Preserve);
XmlTextReader reader = new XmlTextReader(uie.OuterXml, XmlNodeType.Element, xpc);
XmlSerializer serializer = new XmlSerializer(typeof(UpdateInfo), nsm.LookupNamespace(Properties.Strings.UpdateInfoNamespacePrefix));
_updateList.Add(serializer.Deserialize(reader) as UpdateInfo);
} catch (Exception ex) {
Console.WriteLine(ex.ToString());
}
}
_updateList.Sort(new UpdateInfoVersionComparer());
if (_updateList.Count > 0)
{
UpdateInfo _updateInfo = UpdateInfoList[UpdateInfoList.GetLatestVersion( )];
foreach (UpdateFile uf in _updateInfo.Files)
{
if (uf.Version.CompareTo(this.Version) > 0)
{
_updatesAvailable = true;
}
}
if (_updatesAvailable || _updateInfo.Version.CompareTo(this.Version) > 0)
{
OnUpdateAvailable(new UpdatesAvailableEventArgs(_updateInfo.Version));
}
}
}
private List <ValidationResult> ValidateSchema(string fileName, ValidationProfile profile, byte[] sourceData, XmlNamespaceManager nsManager)
{
Dictionary <string, string> namespaces = null;
XmlSchemaCollection schemas = new XmlSchemaCollection();
schemas.Add(Helper.GetSchema(profile.SchemaLocation, out namespaces));
XmlParserContext context = new XmlParserContext(null, nsManager, null, XmlSpace.None);
using (MemoryStream sourceStream = new MemoryStream(sourceData))
{
XmlValidatingReader validatingReader = new XmlValidatingReader(sourceStream, XmlNodeType.Document, context);
validatingReader.ValidationType = ValidationType.Schema;
validatingReader.Schemas.Add(schemas);
List <ValidationResult> results = new List <ValidationResult>();
ValidationResult newResult = null;
validatingReader.ValidationEventHandler += new ValidationEventHandler(delegate(object sender, ValidationEventArgs e)
{
newResult = new ValidationResult()
{
FileName = fileName,
ErrorMessage = e.Message,
Severity = e.Severity.ToString(),
TestContext = "Schema",
Test = "N/A",
Location = "N/A",
LineNumber = e.Exception.LineNumber
};
results.Add(newResult);
});
while (validatingReader.Read())
{
if (newResult != null)
{
newResult.Test = validatingReader.Name;
results.Add(newResult);
newResult = null;
}
}
return(results);
}
}
/// <summary>
/// Implements the following function
/// node-set exsl:node-set(object)
/// </summary>
/// <param name="o"></param>
/// <returns></returns>
public XPathNodeIterator nodeSet(object o)
{
if (o is XPathNavigator)
{
XPathNavigator nav = (XPathNavigator)o;
if (selectItself == null)
{
selectItself = nav.Compile(".");
}
return(nav.Select(selectItself.Clone()));
}
else if (o is XPathNodeIterator)
{
return(o as XPathNodeIterator);
}
else
{
string s;
if (o is string)
{
s = o as string;
}
else if (o is bool)
{
s = ((bool)o)? "true" : "false";
}
else if (o is Double || o is Int16 || o is UInt16 || o is Int32 ||
o is UInt32 || o is Int64 || o is UInt64 || o is Single || o is Decimal)
{
s = o.ToString();
}
else
{
return(null);
}
//Now convert it to text node
XmlParserContext context = new XmlParserContext(null, null, null, XmlSpace.None);
XPathDocument doc = new XPathDocument(
new XmlTextReader("<d>" + s + "</d>", XmlNodeType.Element, context));
XPathNavigator nav = doc.CreateNavigator();
if (selectText == null)
{
selectText = nav.Compile("/d/text()");
}
return(nav.Select(selectText.Clone()));
}
}
/// <summary>Converts an <see cref="T:System.Windows.Markup.ParserContext" /> to an <see cref="T:System.Xml.XmlParserContext" />.</summary>
/// <param name="parserContext">The context to convert to an <see cref="T:System.Xml.XmlParserContext" />.</param>
/// <returns>The XML parser context.</returns>
/// <exception cref="T:System.ArgumentNullException">
/// <paramref name="parserContext" /> is <see langword="null" />.</exception>
// Token: 0x060021E5 RID: 8677 RVA: 0x000A98C4 File Offset: 0x000A7AC4
public static XmlParserContext ToXmlParserContext(ParserContext parserContext)
{
if (parserContext == null)
{
throw new ArgumentNullException("parserContext");
}
XmlNamespaceManager xmlNamespaceManager = new XmlNamespaceManager(new NameTable());
XmlSpace xmlSpace = System.Xml.XmlSpace.None;
if (parserContext.XmlSpace != null && parserContext.XmlSpace.Length != 0)
{
TypeConverter converter = TypeDescriptor.GetConverter(typeof(XmlSpace));
if (converter != null)
{
try
{
xmlSpace = (XmlSpace)converter.ConvertFromString(null, TypeConverterHelper.InvariantEnglishUS, parserContext.XmlSpace);
}
catch (FormatException)
{
xmlSpace = System.Xml.XmlSpace.None;
}
}
}
if (parserContext._xmlnsDictionary != null)
{
foreach (object obj in parserContext._xmlnsDictionary.Keys)
{
string prefix = (string)obj;
xmlNamespaceManager.AddNamespace(prefix, parserContext._xmlnsDictionary[prefix]);
}
}
XmlParserContext xmlParserContext = new XmlParserContext(null, xmlNamespaceManager, parserContext.XmlLang, xmlSpace);
if (parserContext.BaseUri == null)
{
xmlParserContext.BaseURI = null;
}
else
{
string components = parserContext.BaseUri.GetComponents(UriComponents.SerializationInfoString, UriFormat.SafeUnescaped);
Uri uri = new Uri(components);
string components2 = uri.GetComponents(UriComponents.SerializationInfoString, UriFormat.UriEscaped);
xmlParserContext.BaseURI = components2;
}
return(xmlParserContext);
}
// Test parser context creation.
public void TestXmlParserContextConstruct()
{
NameTable nt = new NameTable();
NameTable nt2 = new NameTable();
XmlNamespaceManager ns = new XmlNamespaceManager(nt);
XmlParserContext ctx;
// Try to construct with the wrong name table.
try
{
ctx = new XmlParserContext(nt2, ns, null, XmlSpace.None);
Fail("Construct (1)");
}
catch(XmlException)
{
// Success
}
// Check default property values.
ctx = new XmlParserContext(null, ns, null, XmlSpace.None);
AssertEquals("Construct (2)", "", ctx.BaseURI);
AssertEquals("Construct (3)", "", ctx.DocTypeName);
AssertEquals("Construct (4)", null, ctx.Encoding);
AssertEquals("Construct (5)", "", ctx.InternalSubset);
AssertEquals("Construct (6)", nt, ctx.NameTable);
AssertEquals("Construct (7)", ns, ctx.NamespaceManager);
AssertEquals("Construct (8)", "", ctx.PublicId);
AssertEquals("Construct (9)", "", ctx.SystemId);
AssertEquals("Construct (10)", "", ctx.XmlLang);
AssertEquals("Construct (11)", XmlSpace.None, ctx.XmlSpace);
// Check overridden property values.
ctx = new XmlParserContext(nt, null, "doctype",
"pubid", "sysid", "internal",
"base", "lang", XmlSpace.Preserve,
Encoding.UTF8);
AssertEquals("Construct (12)", "base", ctx.BaseURI);
AssertEquals("Construct (13)", "doctype", ctx.DocTypeName);
AssertEquals("Construct (14)", Encoding.UTF8, ctx.Encoding);
AssertEquals("Construct (15)", "internal", ctx.InternalSubset);
AssertEquals("Construct (16)", nt, ctx.NameTable);
AssertEquals("Construct (17)", null, ctx.NamespaceManager);
AssertEquals("Construct (18)", "pubid", ctx.PublicId);
AssertEquals("Construct (19)", "sysid", ctx.SystemId);
AssertEquals("Construct (20)", "lang", ctx.XmlLang);
AssertEquals("Construct (21)", XmlSpace.Preserve, ctx.XmlSpace);
}
public static XmlReader Create(string inputUri, XmlReaderSettings settings, XmlParserContext inputContext)
{
}
public XmlTextReader(string xmlFragment, XmlNodeType fragType, XmlParserContext context)
{
}
public XmlTextReader(System.IO.Stream xmlFragment, XmlNodeType fragType, XmlParserContext context)
{
}
// Test parser context property changes.
public void TestXmlParserContextProperties()
{
NameTable nt = new NameTable();
NameTable nt2 = new NameTable();
XmlNamespaceManager ns = new XmlNamespaceManager(nt);
XmlParserContext ctx = new XmlParserContext
(nt, ns, null, XmlSpace.None);
// Set and check the various properties.
ctx.BaseURI = "xyzzy";
AssertEquals("BaseURI (1)", "xyzzy", ctx.BaseURI);
ctx.BaseURI = null;
AssertEquals("BaseURI (2)", "", ctx.BaseURI);
ctx.DocTypeName = "xyzzy";
AssertEquals("DocTypeName (1)", "xyzzy", ctx.DocTypeName);
ctx.DocTypeName = null;
AssertEquals("DocTypeName (2)", "", ctx.DocTypeName);
ctx.Encoding = Encoding.UTF8;
AssertEquals("Encoding (1)", Encoding.UTF8, ctx.Encoding);
ctx.Encoding = null;
AssertEquals("Encoding (2)", null, ctx.Encoding);
ctx.InternalSubset = "xyzzy";
AssertEquals("InternalSubset (1)", "xyzzy", ctx.InternalSubset);
ctx.InternalSubset = null;
AssertEquals("InternalSubset (2)", "", ctx.InternalSubset);
ctx.NameTable = nt2;
AssertEquals("NameTable (1)", nt2, ctx.NameTable);
ctx.NameTable = null;
AssertEquals("NameTable (2)", null, ctx.NameTable);
ctx.NamespaceManager = null;
AssertEquals("NamespaceManager (1)", null,
ctx.NamespaceManager);
ctx.NamespaceManager = ns;
AssertEquals("NamespaceManager (2)", ns, ctx.NamespaceManager);
ctx.PublicId = "xyzzy";
AssertEquals("PublicId (1)", "xyzzy", ctx.PublicId);
ctx.PublicId = null;
AssertEquals("PublicId (2)", "", ctx.PublicId);
ctx.SystemId = "xyzzy";
AssertEquals("SystemId (1)", "xyzzy", ctx.SystemId);
ctx.SystemId = null;
AssertEquals("PublicId (2)", "", ctx.SystemId);
ctx.XmlLang = "xyzzy";
AssertEquals("XmlLang (1)", "xyzzy", ctx.XmlLang);
ctx.XmlLang = null;
AssertEquals("XmlLang (2)", "", ctx.XmlLang);
ctx.XmlSpace = XmlSpace.Default;
AssertEquals("XmlSpace (1)", XmlSpace.Default, ctx.XmlSpace);
ctx.XmlSpace = XmlSpace.None;
AssertEquals("XmlSpace (2)", XmlSpace.None, ctx.XmlSpace);
}
public static XmlReader Create(TextReader input, XmlReaderSettings settings, XmlParserContext inputContext);
public static XmlReader Create(System.IO.TextReader input, XmlReaderSettings settings, XmlParserContext inputContext)
{
}
private XmlReader CreateContextReader(string xml, bool fromCurrentNode)
{
if (xml == null)
{
throw new ArgumentNullException("xml");
}
// We have to set the namespace context for the reader.
XPathNavigator editor = CreateNavigator();
// scope starts from parent.
XmlNamespaceManager mgr = new XmlNamespaceManager(NameTable);
if (!fromCurrentNode)
{
editor.MoveToParent(); // should always succeed.
}
if (editor.MoveToFirstNamespace(XPathNamespaceScope.All))
{
do
{
mgr.AddNamespace(editor.LocalName, editor.Value);
}
while (editor.MoveToNextNamespace(XPathNamespaceScope.All));
}
XmlParserContext context = new XmlParserContext(NameTable, mgr, null, XmlSpace.Default);
return XmlReader.Create(new StringReader(xml), new XmlReaderSettings(), context);
}
public XmlParserContext GetParserContext()
{
NameTable nt = new NameTable();
XmlParserContext pc = new XmlParserContext(nt, new XmlNamespaceManager(nt), null, XmlSpace.Default);
return pc;
}
public static bool Create(String url, XmlReaderSettings settings, XmlParserContext context)
{
XmlReader reader = null;
try
{
reader = ReaderHelper.Create(url, settings, context);
while (reader.Read()) ;
return true;
}
catch (ArgumentNullException ane)
{
CError.WriteLineIgnore(ane.ToString());
return false;
}
finally
{
if (reader != null)
reader.Dispose();
}
}
