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;
}
