public void Constructor2 () { XmlDocument doc = new XmlDocument (); XmlNamespaceManager ns = new XmlNamespaceManager (doc.NameTable); XmlParserContext pc = new XmlParserContext (doc.NameTable, ns, "dunno", XmlSpace.None, Encoding.UTF8); Assert.AreEqual (string.Empty, pc.BaseURI, "#A1"); Assert.AreEqual (string.Empty, pc.DocTypeName, "#A2"); Assert.AreEqual (Encoding.UTF8, pc.Encoding, "#A3"); Assert.AreEqual (string.Empty, pc.InternalSubset, "#A4"); Assert.AreSame (ns, pc.NamespaceManager, "#A5"); Assert.AreSame (doc.NameTable, pc.NameTable, "#A6"); Assert.AreEqual (string.Empty, pc.PublicId, "#A7"); Assert.AreEqual (string.Empty, pc.SystemId, "#A8"); Assert.AreEqual ("dunno", pc.XmlLang, "#A9"); Assert.AreEqual (XmlSpace.None, pc.XmlSpace, "#A10"); pc = new XmlParserContext ((NameTable) null, (XmlNamespaceManager) null, (string) null, XmlSpace.None, (Encoding) null); Assert.AreEqual (string.Empty, pc.BaseURI, "#B1"); Assert.AreEqual (string.Empty, pc.DocTypeName, "#B2"); Assert.IsNull (pc.Encoding, "#B3"); Assert.AreEqual (string.Empty, pc.InternalSubset, "#B4"); Assert.IsNull (pc.NamespaceManager, "#B5"); Assert.IsNull (pc.NameTable, "#B6"); Assert.AreEqual (string.Empty, pc.PublicId, "#B7"); Assert.AreEqual (string.Empty, pc.SystemId, "#B8"); Assert.AreEqual (string.Empty, pc.XmlLang, "#B9"); Assert.AreEqual (XmlSpace.None, pc.XmlSpace, "#B10"); }
public static List<WPAuthor> ImportAuthors(string fileLocation) { try { var nsm = new XmlNamespaceManager(new NameTable()); nsm.AddNamespace("wp", "http://wordpress.org/export/1.2/excerpt/"); var parseContext = new XmlParserContext(null, nsm, null, XmlSpace.Default); using (var reader = XmlReader.Create(fileLocation, null, parseContext)) { var doc = XDocument.Load(reader); string WordpressNamespace = "http://wordpress.org/export/1.2/"; XNamespace wpContent = WordpressNamespace; List<WPAuthor> blogAuthors = new List<WPAuthor>(); foreach (XElement element in doc.Descendants("channel")) { foreach (XElement e in element.Descendants(wpContent + "author")) { WPAuthor auth = new WPAuthor(e); blogAuthors.Add(auth); } } return blogAuthors; } } catch (Exception ex) { Log.Error("Failed to import authors: " + ex.Message, "WP Importer"); return new List<WPAuthor>(); } }
public static string ExtractQuery(string fileName, TextWriter errorlogger) { try { string data = File.ReadAllText(fileName); 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(); if (reader.NodeType == XmlNodeType.Text) { return data; } XmlReader reader2 = reader.ReadSubtree(); StringBuilder output = new StringBuilder(); using (XmlWriter writer = XmlWriter.Create(output)) { writer.WriteNode(reader2, true); } StringReader reader3 = new StringReader(data); for (int i = 0; i < reader.LineNumber; i++) { reader3.ReadLine(); } return reader3.ReadToEnd().Trim(); } catch (Exception ex) { errorlogger.WriteLine(ex.Message); errorlogger.WriteLine(ex.StackTrace); } return string.Format("//Error loading the file - {0} .The the linq file might be a linqpad expression which is not supported in the viewer currently." ,fileName); }
/// <summary> /// Validates XML definition against given XSD schema. /// </summary> /// <param name="xmlFileName">Full path to the XML file on file system.</param> /// <param name="schemaContent">XSD schema.</param> /// <param name="schemaName">XSD schema name.</param> public void Validate(string xmlFileName, string schemaContent, string schemaName) { _xmlFileName = xmlFileName; var xmlDoc = GetUpdatedXml(xmlFileName, schemaName); var xmlSchemaSet = GetXmlSchema(schemaContent, schemaName); var nt = new NameTable(); var nsmgr = new XmlNamespaceManager(nt); var context = new XmlParserContext(null, nsmgr, null, XmlSpace.None); var settings = new XmlReaderSettings(); settings.ValidationType = ValidationType.Schema; settings.Schemas.Add(xmlSchemaSet); settings.ValidationEventHandler += ValidationCallbackOne; using (var xmlr = new XmlTextReader(xmlDoc.OuterXml, XmlNodeType.Document, context)) { using (var reader = XmlReader.Create(xmlr, settings)) { while (reader.Read()) { var val = reader.Value; } } } }
/// <summary> /// Implements ParseXML /// </summary> /// <returns></returns> public IXmlResult ParseIATIXML(string url) { IXmlResult xmlResult; var serializer = new XmlSerializer(typeof(XmlResultv1), new XmlRootAttribute("result")); // Create an XmlNamespaceManager to resolve namespaces. NameTable nameTable = new NameTable(); XmlNamespaceManager nsmgr = new XmlNamespaceManager(nameTable); nsmgr.AddNamespace("iati-extra", ""); // Create an XmlParserContext. The XmlParserContext contains all the information // required to parse the XML fragment, including the entity information and the // XmlNamespaceManager to use for namespace resolution. XmlParserContext xmlParserContext = new XmlParserContext(nameTable, nsmgr, null, XmlSpace.None); // Create the reader. XmlReaderSettings xmlReaderSettings = new XmlReaderSettings(); xmlReaderSettings.NameTable = nameTable; using (var Reader = XmlReader.Create(url, xmlReaderSettings, xmlParserContext)) { xmlResult = (XmlResultv1)serializer.Deserialize(Reader); } return xmlResult; }
/// <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()); } }
public static List<Issue> GetIssueListFromXmlStream(Stream stream) { List<Issue> issues = new List<Issue>(); XmlTextReader reader = new XmlTextReader(stream); XmlDocument doc = new XmlDocument(); doc.Load(reader); reader.Close(); XmlNodeList list = doc.DocumentElement.GetElementsByTagName("item"); XmlSerializer s = new XmlSerializer(typeof(Issue)); //Create the XmlNamespaceManager. NameTable nt = new NameTable(); XmlNamespaceManager nsmgr = new XmlNamespaceManager(nt); nsmgr.AddNamespace("jc", "urn:jiraconn"); //Create the XmlParserContext. XmlParserContext context = new XmlParserContext(null, nsmgr, null, XmlSpace.None); foreach (XmlNode item in list) { //Create the reader. XmlTextReader itemReader = new XmlTextReader(item.OuterXml, XmlNodeType.Element, context); Issue issue = (Issue)s.Deserialize(itemReader); issues.Add(issue); } return issues; }
public XmlValidatingReader( Stream xmlFragment, XmlNodeType fragType, XmlParserContext context ) { if (xmlFragment == null) { throw new ArgumentNullException("xmlFragment"); } impl = new XmlValidatingReaderImpl(xmlFragment, fragType, context); impl.OuterReader = this; }
public string RenderComponentFieldAsBBCode(string fieldExpression, int fieldIndex, bool outputImages) { BuiltInFunctions functions = new BuiltInFunctions(_engine, _package); string output = functions.RenderComponentField(fieldExpression, fieldIndex); StringReader sr = new StringReader(output); NameTable nt = new NameTable(); XmlNamespaceManager nsmgr = new XmlNamespaceManager(nt); nsmgr.AddNamespace("tcdl", Tridion.ContentManager.Templating.TcdlTags.TcdlNamespace); XmlParserContext parserContext = new XmlParserContext(null, nsmgr, null, XmlSpace.None); XmlReader xmlReader = XmlReader.Create(sr, new XmlReaderSettings(), parserContext); XslCompiledTransform transform = new XslCompiledTransform(true); using (Stream xsltStream = System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream("Tridion.ContentManager.Templating.Expression.NetbiscuitsFunctions.XhtmlToBBCode.xslt")) { using (XmlReader xsltReader = XmlReader.Create(xsltStream)) { transform.Load(xsltReader); } } StringWriter resultWriter = new StringWriter(); XsltArgumentList argumentList = new XsltArgumentList(); argumentList.AddParam("IncludeImages", String.Empty, outputImages); transform.Transform(xmlReader, argumentList, resultWriter); return resultWriter.ToString(); }
/// <summary> /// Constructs an <see cref="IContainerProfile"/> /// from a XML fragment. /// </summary> /// <param name="xmlContents"></param> /// <returns></returns> public virtual IContainerProfile Build(String xmlContents) { XmlNamespaceManager nsManager = new XmlNamespaceManager(new NameTable()); XmlParserContext context = new XmlParserContext(null, nsManager, null, XmlSpace.None); XmlReader reader = new XmlTextReader(xmlContents, XmlNodeType.Element, context); return Build(reader); }
public XmlValidatingReader(String xmlFragment, XmlNodeType fragType, XmlParserContext context) { reader = new XmlTextReader(xmlFragment, fragType, context); entityHandling = EntityHandling.ExpandEntities; validationType = ValidationType.Auto; reader.Normalization = true; }
static void Main(string[] args) { try { //XML fragment para validar string xmlFrag = @"<address myns:Pais='port' myns:PaisCode='351' xmlns='http://SD/PTAddress.xsd' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' >" + "<nome>ISEL</nome>" + "<rua>Conselheiro Emidio Navarro</rua>" + "<numero>1</numero>" + "<!-- comentario -->" + "<numero>2</numero>" + "<numero>3</numero>" + "<numero>4</numero>" + "<cidade>Lisboa</cidade>" + "<codigo-postal>1950</codigo-postal>" + "</address>"; //Set the settings to xml reader and add the schema XmlReaderSettings settings = new XmlReaderSettings(); settings.Schemas.Add("http://SD/PTAddress.xsd", "..\\..\\XMLSchemaPTAddress.xsd"); settings.ValidationType = ValidationType.Schema; settings.ValidationFlags |= XmlSchemaValidationFlags.AllowXmlAttributes; settings.ValidationFlags |= XmlSchemaValidationFlags.ReportValidationWarnings; settings.ConformanceLevel = ConformanceLevel.Fragment; settings.ValidationEventHandler += new ValidationEventHandler(ShowParserErrors); // Create the XmlNamespaceManager. XmlNamespaceManager nsmgr = new XmlNamespaceManager(new NameTable()); nsmgr.AddNamespace("myns", "http://SD/PTAddress.xsd"); // Create the XmlParserContext. XmlParserContext context = new XmlParserContext(null, nsmgr, null, XmlSpace.None); XmlReader reader = XmlReader.Create(new StringReader(xmlFrag), settings, context); while (reader.Read()) { //ler toda a string com fragmento xml } if (!erro) Console.WriteLine("XML fragment VÁLIDO"); } catch (XmlException XmlExp) { Console.WriteLine(XmlExp.Message); } catch (XmlSchemaException XmlSchExp) { Console.WriteLine(XmlSchExp.Message); } catch (Exception GenExp) { Console.WriteLine(GenExp.Message); } finally { Console.Read(); } }
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 Parse1 () { 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); while (xr.Read ()) {} }
public XmlValidatingReader(string xmlFragment, XmlNodeType fragType, XmlParserContext context) { if (xmlFragment == null) { throw new ArgumentNullException(nameof(xmlFragment)); } _impl = new XmlValidatingReaderImpl(xmlFragment, fragType, context); _impl.OuterReader = this; }
public static XmlDocument ReadAddonXml(CarbonFile file) { var document = new XmlDocument(); XmlParserContext context = new XmlParserContext(null, XmlNamespace, string.Empty, XmlSpace.Default); XmlReader reader = XmlReader.Create(file.GetPath(), XmlSettings, context); document.Load(reader); return document; }
/// <summary> /// An XML reader is needed to access the XML strings as nodes by the XmlDiff Compare method. /// </summary> /// <param name="xmlElement">An XML string that is a single element, most usefull when containing other nodes.</param> /// <returns>An XML reader for this string.</returns> private XmlReader StringToXmlReader(string xmlElement) { XmlNodeType fragType = XmlNodeType.Element; string xmlLang = ""; System.Xml.XmlSpace xmlSpace = XmlSpace.None; XmlNameTable nt = new NameTable(); System.Xml.XmlNamespaceManager nsMgr = new XmlNamespaceManager(nt); XmlParserContext context = new XmlParserContext(nt, nsMgr, xmlLang, xmlSpace); return new XmlTextReader(xmlElement, fragType, context); }
internal static XmlParserContext CreateStrict() { XmlNameTable nameTable = new NameTable(); XmlNamespaceManager namespaceManager = new XmlNamespaceManager(nameTable); XmlParserContext context = new XmlParserContext(nameTable, namespaceManager, null, XmlSpace.None); context.DocTypeName = "html"; context.PublicId = "-//W3C//DTD XHTML 1.0 Strict//EN"; context.SystemId = "xhtml1-strict.dtd"; return context; }
public Log4JParserForRemoteMessage( IRetrieveProcesses processRetriever, IHaveExtendedProperties extendedProperties) { Verify.NotNull(processRetriever, "processRetriever"); Verify.NotNull(extendedProperties, "extendedProperties"); this.xmlNamespaceManager = new XmlNamespaceManager(new NameTable()); this.xmlNamespaceManager.AddNamespace("log4j", "http://logging.apache.org/log4j/"); this.xmlParserContext = new XmlParserContext(null, this.xmlNamespaceManager, null, XmlSpace.None); }
protected XmlMessageParser(IRetrieveProcesses processRetriever, String namespacePrefix, String namespaceUri) { Verify.NotNull(processRetriever, "processRetriever"); Verify.NotWhitespace(namespacePrefix, "namespacePrefix"); Verify.NotWhitespace(namespaceUri, "namespaceUri"); processes = processRetriever; xmlNamespaceManager = new XmlNamespaceManager(new NameTable()); xmlNamespaceManager.AddNamespace(namespacePrefix, namespaceUri); xmlParserContext = new XmlParserContext(null, xmlNamespaceManager, null, XmlSpace.None); }
private void Page_Load(object sender, System.EventArgs e) { XmlValidatingReader reader = null; XmlSchemaCollection myschema = new XmlSchemaCollection(); ValidationEventHandler eventHandler = new ValidationEventHandler(ShowCompileErrors ); try { String xmlFrag = @"<?xml version='1.0' ?> <item> <xxx:price xmlns:xxx='xxx' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:schemaLocation='test.xsd'></xxx:price> </item>"; /*"<author xmlns='urn:bookstore-schema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>" + "<first-name>Herman</first-name>" + "<last-name>Melville</last-name>" + "</author>";*/ string xsd = @"<?xml version='1.0' encoding='UTF-8'?> <xsd:schema xmlns:xsd='http://www.w3.org/2001/XMLSchema' targetNamespace='xxx'> <xsd:element name='price' type='xsd:integer' xsd:default='12'/> </xsd:schema>"; //Create the XmlParserContext. XmlParserContext context = new XmlParserContext(null, null, "", XmlSpace.None); //Implement the reader. reader = new XmlValidatingReader(xmlFrag, XmlNodeType.Element, context); //Add the schema. myschema.Add("xxx", new XmlTextReader(new StringReader(xsd))); //Set the schema type and add the schema to the reader. reader.ValidationType = ValidationType.Schema; reader.Schemas.Add(myschema); while (reader.Read()){Response.Write(reader.Value);} Response.Write("<br>Completed validating xmlfragment<br>"); } catch (XmlException XmlExp) { Response.Write(XmlExp.Message + "<br>"); } catch(XmlSchemaException XmlSchExp) { Response.Write(XmlSchExp.Message + "<br>"); } catch(Exception GenExp) { Response.Write(GenExp.Message + "<br>"); } finally {} XmlDocument doc; }
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 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); }
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; }
#pragma warning disable 618 // Creates a XmlValidatingReader suitable for parsing InnerXml strings private XmlReader CreateInnerXmlReader(string xmlFragment, XmlNodeType nt, XmlParserContext context, XmlDocument doc) { XmlNodeType contentNT = nt; if (contentNT == XmlNodeType.Entity || contentNT == XmlNodeType.EntityReference) { contentNT = XmlNodeType.Element; } XmlTextReaderImpl tr = new XmlTextReaderImpl(xmlFragment, contentNT, context); tr.XmlValidatingReaderCompatibilityMode = true; if (doc.HasSetResolver) { tr.XmlResolver = doc.GetResolver(); } if (!(doc.ActualLoadingStatus)) { tr.DisableUndeclaredEntityCheck = true; } Debug.Assert(tr.EntityHandling == EntityHandling.ExpandCharEntities); XmlDocumentType dtdNode = doc.DocumentType; if (dtdNode != null) { tr.Namespaces = dtdNode.ParseWithNamespaces; if (dtdNode.DtdSchemaInfo != null) { tr.SetDtdInfo(dtdNode.DtdSchemaInfo); } else { IDtdParser dtdParser = DtdParser.Create(); XmlTextReaderImpl.DtdParserProxy proxy = new XmlTextReaderImpl.DtdParserProxy(tr); IDtdInfo dtdInfo = dtdParser.ParseFreeFloatingDtd(context.BaseURI, context.DocTypeName, context.PublicId, context.SystemId, context.InternalSubset, proxy); dtdNode.DtdSchemaInfo = dtdInfo as SchemaInfo; tr.SetDtdInfo(dtdInfo); } } if (nt == XmlNodeType.Entity || nt == XmlNodeType.EntityReference) { tr.Read(); //this will skip the first element "wrapper" tr.ResolveEntity(); } return(tr); }
internal XmlValidatingReaderImpl(string xmlFragment, XmlNodeType fragType, XmlParserContext context) : this(new XmlTextReader(xmlFragment, fragType, context)) { if (coreReader.BaseURI.Length > 0) { validator.BaseUri = GetResolver().ResolveUri(null, coreReader.BaseURI); } if (context != null) { parsingFunction = ParsingFunction.ParseDtdFromContext; parserContext = context; } }
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); }
private XmlReader CreateInnerXmlReader(string xmlFragment, XmlNodeType nt, XmlParserContext context, XmlDocument doc) { XmlNodeType fragType = nt; switch (fragType) { case XmlNodeType.Entity: case XmlNodeType.EntityReference: fragType = XmlNodeType.Element; break; } XmlTextReaderImpl reader = new XmlTextReaderImpl(xmlFragment, fragType, context) { XmlValidatingReaderCompatibilityMode = true }; if (doc.HasSetResolver) { reader.XmlResolver = doc.GetResolver(); } if (!doc.ActualLoadingStatus) { reader.DisableUndeclaredEntityCheck = true; } XmlDocumentType documentType = doc.DocumentType; if (documentType != null) { reader.Namespaces = documentType.ParseWithNamespaces; if (documentType.DtdSchemaInfo != null) { reader.SetDtdInfo(documentType.DtdSchemaInfo); } else { IDtdParser parser = DtdParser.Create(); XmlTextReaderImpl.DtdParserProxy adapter = new XmlTextReaderImpl.DtdParserProxy(reader); IDtdInfo newDtdInfo = parser.ParseFreeFloatingDtd(context.BaseURI, context.DocTypeName, context.PublicId, context.SystemId, context.InternalSubset, adapter); documentType.DtdSchemaInfo = newDtdInfo as SchemaInfo; reader.SetDtdInfo(newDtdInfo); } } if ((nt == XmlNodeType.Entity) || (nt == XmlNodeType.EntityReference)) { reader.Read(); reader.ResolveEntity(); } return(reader); }
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 List<WpPost> GetPosts(WpImportOptions options) { var nsm = new XmlNamespaceManager(new NameTable()); nsm.AddNamespace("atom", "http://www.w3.org/2005/Atom"); var parseContext = new XmlParserContext(null, nsm, null, XmlSpace.Default); using (var reader = XmlReader.Create(_fileLocation, null, parseContext)) { var doc = XDocument.Load(reader); var posts = (from item in doc.Descendants("item") select new WpPost(item, options)).ToList(); return posts; } }
/// <summary> /// Imports the specified file. /// </summary> /// <param name="fileLocation">The file location.</param> /// <param name="includeComments">Determines if comments should be imported</param> /// <param name="includeCategories">Determines if categories should be imported</param> /// <param name="includeTags">Determines if tags should be imported</param> public static List<WpPost> Import(string fileLocation, bool includeComments, bool includeCategories, bool includeTags) { var nsm = new XmlNamespaceManager(new NameTable()); nsm.AddNamespace("atom", "http://www.w3.org/2005/Atom"); var parseContext = new XmlParserContext(null, nsm, null, XmlSpace.Default); using (var reader = XmlReader.Create(fileLocation, null, parseContext)) { var doc = XDocument.Load(reader); var posts = (from item in doc.Descendants("item") select new WpPost(item, includeComments, includeCategories, includeTags)).ToList(); return posts; } }
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); } }
public static bool CompareXml(Stream expectedStream, Stream actualStream, string xmldiffoptionvalue, DelayedWriteLogger logger) { bool bResult = false; // Default Diff options used by XSLT V2 driver. int defaultXmlDiffOptions = (int)(XmlDiffOption.InfosetComparison | XmlDiffOption.IgnoreEmptyElement | XmlDiffOption.IgnoreAttributeOrder); XmlDiff diff = new XmlDiff(); if (xmldiffoptionvalue == null || xmldiffoptionvalue.Equals(string.Empty)) diff.Option = (XmlDiffOption)defaultXmlDiffOptions; else { if (logger != null) logger.LogMessage("Custom XmlDiffOptions used. Value passed is " + xmldiffoptionvalue); diff.Option = (XmlDiffOption)Int32.Parse(xmldiffoptionvalue); } XmlParserContext context = new XmlParserContext(new NameTable(), null, "", XmlSpace.None); try { bResult = diff.Compare(new XmlTextReader(actualStream, XmlNodeType.Element, context), new XmlTextReader(expectedStream, XmlNodeType.Element, context)); } catch (Exception e) { bResult = false; if (logger != null) { logger.LogMessage("Exception thrown in XmlDiff compare!"); logger.LogXml(e.ToString()); throw; } } if (bResult) return true; if (logger != null) { logger.LogMessage("Mismatch in XmlDiff"); logger.LogMessage("Actual result: "); } return false; }
internal XmlReader CreateReader(TextReader input, string baseUriString, XmlParserContext inputContext) { if (input == null) { throw new ArgumentNullException("input"); } if (baseUriString == null) { baseUriString = string.Empty; } XmlReader reader = new XmlTextReaderImpl(input, this, baseUriString, inputContext); if (this.ValidationType != System.Xml.ValidationType.None) { reader = this.AddValidation(reader); } return(reader); }
public static XmlReader Create(string url, XmlReaderSettings settings, XmlParserContext context) { settings = PopulateSettings(settings); bool closeInputBak = settings.CloseInput; try { settings.CloseInput = true; // forced. See XmlReaderCommonTests.CreateFromUrlClose(). if (context == null) { context = PopulateParserContext(settings, url); } XmlTextReader xtr = new XmlTextReader(false, settings.XmlResolver, url, GetNodeType(settings), context); XmlReader ret = CreateCustomizedTextReader(xtr, settings); return(ret); } finally { settings.CloseInput = closeInputBak; } }
internal XmlReader CreateReader(string inputUri, XmlParserContext inputContext) { XmlReader reader; if (inputUri == null) { throw new ArgumentNullException("inputUri"); } if (inputUri.Length == 0) { throw new ArgumentException(Res.GetString("XmlConvert_BadUri"), "inputUri"); } System.Xml.XmlResolver xmlResolver = this.GetXmlResolver(); if (xmlResolver == null) { xmlResolver = this.CreateDefaultResolver(); } Uri absoluteUri = xmlResolver.ResolveUri(null, inputUri); Stream input = (Stream)xmlResolver.GetEntity(absoluteUri, string.Empty, typeof(Stream)); if (input == null) { throw new XmlException("Xml_CannotResolveUrl", inputUri); } XmlReaderSettings settings = this; if (!settings.CloseInput) { settings = settings.Clone(); settings.CloseInput = true; } try { reader = settings.CreateReader(input, absoluteUri, null, inputContext); } catch { input.Close(); throw; } return(reader); }
void SetEntityContent() { if (lastLinkedChild != null) { return; } XmlDocumentType doctype = OwnerDocument.DocumentType; if (doctype == null) { return; } #if NOT_PFX DTDEntityDeclaration decl = doctype.DTD.EntityDecls [name]; if (decl == null) { return; } XmlNamespaceManager nsmgr = this.ConstructNamespaceManager(); XmlParserContext ctx = new XmlParserContext(OwnerDocument.NameTable, nsmgr, doctype != null ? doctype.DTD : null, BaseURI, XmlLang, XmlSpace, null); XmlTextReader xmlReader = new XmlTextReader(decl.EntityValue, XmlNodeType.Element, ctx); xmlReader.XmlResolver = OwnerDocument.Resolver; do { XmlNode n = OwnerDocument.ReadNode(xmlReader); if (n == null) { break; } InsertBefore(n, null, false, false); } while (true); #endif }
private void ParseDocumentType(XmlDocumentType dtNode, bool bUseResolver, XmlResolver resolver) { this.doc = dtNode.OwnerDocument; XmlParserContext context = new XmlParserContext(null, new XmlNamespaceManager(this.doc.NameTable), null, null, null, null, this.doc.BaseURI, string.Empty, XmlSpace.None); XmlTextReaderImpl reader = new XmlTextReaderImpl("", XmlNodeType.Element, context) { Namespaces = dtNode.ParseWithNamespaces }; if (bUseResolver) { reader.XmlResolver = resolver; } IDtdParser parser = DtdParser.Create(); XmlTextReaderImpl.DtdParserProxy adapter = new XmlTextReaderImpl.DtdParserProxy(reader); IDtdInfo dtdInfo = parser.ParseFreeFloatingDtd(this.doc.BaseURI, dtNode.Name, dtNode.PublicId, dtNode.SystemId, dtNode.InternalSubset, adapter); this.LoadDocumentType(dtdInfo, dtNode); }
private void ParseDocumentType(XmlDocumentType dtNode, bool bUseResolver, XmlResolver resolver) { _doc = dtNode.OwnerDocument; XmlParserContext pc = new XmlParserContext(null, new XmlNamespaceManager(_doc.NameTable), null, null, null, null, _doc.BaseURI, string.Empty, XmlSpace.None); XmlTextReaderImpl tr = new XmlTextReaderImpl("", XmlNodeType.Element, pc); tr.Namespaces = dtNode.ParseWithNamespaces; if (bUseResolver) { tr.XmlResolver = resolver; } IDtdParser dtdParser = DtdParser.Create(); XmlTextReaderImpl.DtdParserProxy proxy = new XmlTextReaderImpl.DtdParserProxy(tr); IDtdInfo dtdInfo = dtdParser.ParseFreeFloatingDtd(_doc.BaseURI, dtNode.Name, dtNode.PublicId, dtNode.SystemId, dtNode.InternalSubset, proxy); LoadDocumentType(dtdInfo, dtNode); }
internal XmlNamespaceManager ParsePartialContent(XmlNode parentNode, string innerxmltext, XmlNodeType nt) { //the function shouldn't be used to set innerxml for XmlDocument node Debug.Assert(parentNode.NodeType != XmlNodeType.Document); _doc = parentNode.OwnerDocument; Debug.Assert(_doc != null); XmlParserContext pc = GetContext(parentNode); _reader = CreateInnerXmlReader(innerxmltext, nt, pc, _doc); try { _preserveWhitespace = true; bool bOrigLoading = _doc.IsLoading; _doc.IsLoading = true; if (nt == XmlNodeType.Entity) { XmlNode?node = null; while (_reader.Read() && (node = LoadNodeDirect()) != null) { parentNode.AppendChildForLoad(node, _doc); } } else { XmlNode?node = null; while (_reader.Read() && (node = LoadNode(true)) != null) { parentNode.AppendChildForLoad(node, _doc); } } _doc.IsLoading = bOrigLoading; } finally { _reader.Close(); } return(pc.NamespaceManager !); }
#pragma warning disable 618 // Creates a XmlValidatingReader suitable for parsing InnerXml strings private XmlReader CreateInnerXmlReader(String xmlFragment, XmlNodeType nt, XmlParserContext context, XmlDocument doc) { XmlNodeType contentNT = nt; if (contentNT == XmlNodeType.Entity || contentNT == XmlNodeType.EntityReference) { contentNT = XmlNodeType.Element; } TextReader fragmentReader = new StringReader(xmlFragment); XmlReaderSettings settings = new XmlReaderSettings { ConformanceLevel = ConformanceLevel.Fragment }; XmlReader tr = XmlReader.Create(fragmentReader, settings, context); if (nt == XmlNodeType.Entity || nt == XmlNodeType.EntityReference) { tr.Read(); //this will skip the first element "wrapper" tr.ResolveEntity(); } return(tr); }
internal XmlReader CreateReader(TextReader input, string baseUriString, XmlParserContext inputContext) { if (input == null) { throw new ArgumentNullException(nameof(input)); } if (baseUriString == null) { baseUriString = string.Empty; } // create xml text reader XmlReader reader = new XmlTextReaderImpl(input, this, baseUriString, inputContext); if (_useAsync) { reader = XmlAsyncCheckReader.CreateAsyncCheckWrapper(reader); } return(reader); }
internal XmlReader CreateReader(String inputUri, XmlParserContext inputContext) { if (inputUri == null) { throw new ArgumentNullException("inputUri"); } if (inputUri.Length == 0) { throw new ArgumentException(Res.GetString(Res.XmlConvert_BadUri), "inputUri"); } // resolve and open the url XmlResolver tmpResolver = this.GetXmlResolver(); if (tmpResolver == null) { tmpResolver = CreateDefaultResolver(); } // create text XML reader XmlReader reader = new XmlTextReaderImpl(inputUri, this, inputContext, tmpResolver); #if !SILVERLIGHT // wrap with validating reader if (this.ValidationType != ValidationType.None) { reader = AddValidation(reader); } #endif #if ASYNC if (useAsync) { reader = XmlAsyncCheckReader.CreateAsyncCheckWrapper(reader); } #endif return(reader); }
// Creates a XmlValidatingReader suitable for parsing InnerXml strings private XmlReader CreateInnerXmlValidatingReader(String xmlFragment, XmlNodeType nt, XmlParserContext context, XmlDocument doc) { XmlNodeType contentNT = nt; if (contentNT == XmlNodeType.Entity || contentNT == XmlNodeType.EntityReference) { contentNT = XmlNodeType.Element; } XmlValidatingReader xmlvr = new XmlValidatingReader(xmlFragment, contentNT, context); if (doc.DocumentType != null) { xmlvr.Namespaces = doc.DocumentType.ParseWithNamespaces; } if (doc.HasSetResolver) { xmlvr.XmlResolver = doc.GetResolver(); } xmlvr.ValidationType = ValidationType.None; if (!(doc.ActualLoadingStatus)) { xmlvr.DisableUndeclaredEntityCheck = true; } // all these settings are alreay the default setting in XmlTextReader xmlvr.EntityHandling = EntityHandling.ExpandCharEntities; if (nt == XmlNodeType.Entity || nt == XmlNodeType.EntityReference) { xmlvr.Read(); //this will skip the first element "wrapper" xmlvr.ResolveEntity(); } return(xmlvr); }
public XmlValidatingReader(string xmlFragment, XmlNodeType fragType, XmlParserContext context) : this(new XmlTextReader(xmlFragment, fragType, context)) { }
internal XmlReader CreateReader(Stream input, Uri baseUri, string baseUriString, XmlParserContext inputContext) { if (input == null) { throw new ArgumentNullException(nameof(input)); } if (baseUriString == null) { if (baseUri == null) { baseUriString = string.Empty; } else { baseUriString = baseUri.ToString(); } } // create text XML reader XmlReader reader = new XmlTextReaderImpl(input, null, 0, this, baseUri, baseUriString, inputContext, _closeInput); // wrap with validating reader if (this.ValidationType != ValidationType.None) { reader = AddValidation(reader); } if (_useAsync) { reader = XmlAsyncCheckReader.CreateAsyncCheckWrapper(reader); } return(reader); }
/// <summary> /// 根据XML格式设置DataGrid中的内容 /// </summary> /// <param name="strXML">主表中与DataGrid整体对应的XML字段内容</param> /// <param name="p_objclsElementAttributeArr">只需要赋值其中每项的m_blnIsDST和m_strElementName即可</param> /// <param name="p_dtgGrid">待设置内容的DataGrid名称</param> /// <returns>正确执行返回true,参数错误返回false</returns> public bool m_blnSetDataFromXML(string strXML, bool[] p_blnIsDSTArr, System.Xml.XmlParserContext p_objXmlParser, ref System.Windows.Forms.DataGrid p_dtgGrid) { if (strXML == null || strXML.Trim() == "" || p_blnIsDSTArr == null) { return(false); } DataTable dtbTable = (DataTable)p_dtgGrid.DataSource; p_dtgGrid.CurrentRowIndex = 0; dtbTable.Rows.Clear(); XmlTextReader objReader = new XmlTextReader(strXML, XmlNodeType.Element, p_objXmlParser); objReader.WhitespaceHandling = WhitespaceHandling.None; clsElementAttribute[] objclsElementAttributeArr = new clsElementAttribute[p_blnIsDSTArr.Length]; for (int j0 = 0; j0 < p_blnIsDSTArr.Length; j0++) { objclsElementAttributeArr[j0] = new clsElementAttribute(); objclsElementAttributeArr[j0].m_blnIsDST = p_blnIsDSTArr[j0]; //默认为非DST格式,即为bool类型 } int j2 = 0; while (objReader.Read()) { switch (objReader.NodeType) { case XmlNodeType.Element: // if (objReader.HasAttributes) { objclsElementAttributeArr[j2].m_strValue = objReader.GetAttribute("VALUE"); objclsElementAttributeArr[j2].m_strValueXML = objReader.GetAttribute("VALUEXML"); if (j2 == objclsElementAttributeArr.Length - 1) { Object[] objRes = new object[objclsElementAttributeArr.Length]; for (int k3 = 0; k3 < objclsElementAttributeArr.Length; k3++) { if (objclsElementAttributeArr[k3].m_blnIsDST == false) { objRes[k3] = objclsElementAttributeArr[k3].m_strValue == "True" ? true:false; } else { clsDSTRichTextBoxValue objclsDSTRichTextBoxValue = new clsDSTRichTextBoxValue(); objclsDSTRichTextBoxValue.m_strText = objclsElementAttributeArr[k3].m_strValue; objclsDSTRichTextBoxValue.m_strDSTXml = objclsElementAttributeArr[k3].m_strValueXML; objRes[k3] = objclsDSTRichTextBoxValue; } } dtbTable.Rows.Add(objRes); j2 = 0; } else { j2++; } } break; } } return(true); }
public static XmlReader Create(TextReader reader, XmlReaderSettings settings, XmlParserContext context) { settings = PopulateSettings(settings); if (context == null) { context = PopulateParserContext(settings, String.Empty); } return(CreateCustomizedTextReader(new XmlTextReader(context.BaseURI, reader, GetNodeType(settings), context), settings)); }
public XmlTextReader(Stream xmlFragment, XmlNodeType fragType, XmlParserContext context) { this.impl = new XmlTextReaderImpl(xmlFragment, fragType, context); this.impl.OuterReader = this; }
public XmlTextReader(string xmlFragment, XmlNodeType fragType, XmlParserContext context) { _impl = new XmlTextReaderImpl(xmlFragment, fragType, context); _impl.OuterReader = this; }
internal XmlTextReader(bool dummy, XmlResolver resolver, string url, XmlNodeType fragType, XmlParserContext context) { source = new XmlTextReaderImpl(dummy, resolver, url, fragType, context); }
internal XmlTextReader(string baseURI, TextReader xmlFragment, XmlNodeType fragType, XmlParserContext context) { source = new XmlTextReaderImpl(baseURI, xmlFragment, fragType, context); }
public XmlTextReader(string xmlFragment, XmlNodeType fragType, XmlParserContext context) { source = new XmlTextReaderImpl(xmlFragment, fragType, context); }
public XmlValidatingReader(Stream xmlFragment, XmlNodeType fragType, XmlParserContext context) { impl = new XmlValidatingReaderImpl(xmlFragment, fragType, context); impl.OuterReader = this; }
public XmlValidatingReader([StringSyntax(StringSyntaxAttribute.Xml)] string xmlFragment, XmlNodeType fragType, XmlParserContext context) { ArgumentNullException.ThrowIfNull(xmlFragment); _impl = new XmlValidatingReaderImpl(xmlFragment, fragType, context); _impl.OuterReader = this; }