// Creates XmlDocument from html content and return it with rootitem "<root>".
public static XmlDocument ParseHtml(string sContent)
{
StringReader sr = new StringReader("<root>" + sContent + "</root>");
SgmlReader reader = new SgmlReader();
reader.WhitespaceHandling = WhitespaceHandling.All;
reader.CaseFolding = Sgml.CaseFolding.ToLower;
reader.InputStream = sr;
StringWriter sw = new StringWriter();
XmlTextWriter w = new XmlTextWriter(sw);
w.Formatting = Formatting.Indented;
w.WriteStartDocument();
reader.Read();
while (!reader.EOF)
{
w.WriteNode(reader, true);
}
w.Flush();
w.Close();
sw.Flush();
// create document
XmlDocument doc = new XmlDocument();
doc.PreserveWhitespace = true;
doc.XmlResolver = null;
doc.LoadXml(sw.ToString());
reader.Close();
return doc;
}
public static string GetWellFormedHTML(string html, string xpathNavPath)
{
// StreamReader sReader = null;
StringWriter sw = null;
SgmlReader reader = null;
XmlTextWriter writer = null;
try
{
// if (uri == String.Empty) uri = "http://www.XMLforASP.NET";
// HttpWebRequest req = (HttpWebRequest)WebRequest.Create(uri);
// HttpWebResponse res = (HttpWebResponse)req.GetResponse();
// sReader = new StreamReader(res.GetResponseStream());
reader = new SgmlReader();
reader.DocType = "HTML";
reader.InputStream = new StringReader(html);
sw = new StringWriter();
writer = new XmlTextWriter(sw);
writer.Formatting = Formatting.Indented;
//writer.WriteStartElement("Test");
while (reader.Read())
{
if (reader.NodeType != XmlNodeType.Whitespace)
{
writer.WriteNode(reader, true);
}
}
//writer.WriteEndElement();
if (xpathNavPath == null)
{
string sr = sw.ToString();
sr = sr.Replace("\r", "\n");
sr = sr.Replace("\n\n", "\n");
return sr;
}
else
{ //Filter out nodes from HTML
StringBuilder sb = new StringBuilder();
XPathDocument doc = new XPathDocument(new StringReader(sw.ToString()));
XPathNavigator nav = doc.CreateNavigator();
XPathNodeIterator nodes = nav.Select(xpathNavPath);
while (nodes.MoveNext())
{
sb.Append(nodes.Current.Value + "\n");
}
string sr = sb.ToString();
sr = sr.Replace("\r", "\n");
sr = sr.Replace("\n\n", "\n");
return sr;
}
}
catch (Exception exp)
{
writer.Close();
reader.Close();
sw.Close();
// sReader.Close();
return exp.Message;
}
}
/// <summary>
/// Executes the command logics.
/// </summary>
public override void Invoke()
{
//print request xml
var doc = new XmlDocument();
var stringWriter = new StringWriter();
//get your document
try
{
doc.LoadXml(this.document.Text);
}
catch (Exception)
{
return;
}
//create reader and writer
var xmlReader = new XmlNodeReader(doc);
//set formatting options
var xmlWriter = new XmlTextWriter(stringWriter)
{
Formatting = Formatting.Indented,
Indentation = 3,
IndentChar = ' '
};
//write the document formatted
xmlWriter.WriteNode(xmlReader, true);
this.document.Text = stringWriter.ToString();
}
public static string PrettyPrint(XmlDocument xmlDoc)
{
if (xmlDoc == null)
{
return(null);
}
try
{
using (System.IO.StringWriter sw = new System.IO.StringWriter())
{
System.Xml.XmlNodeReader xmlReader = new System.Xml.XmlNodeReader(xmlDoc);
System.Xml.XmlTextWriter xmlWriter = new System.Xml.XmlTextWriter(sw);
xmlWriter.Formatting = System.Xml.Formatting.Indented;
xmlWriter.Indentation = 4;
xmlWriter.IndentChar = ' ';
xmlWriter.WriteNode(xmlReader, true);
return(sw.ToString());
}
}
catch (Exception)
{
// just return as-is
return(xmlDoc.OuterXml);
}
}
public void TransformingTest()
{
XslTransform tx = new XslTransform();
tx.Load(new XmlTextReader(
Globals.GetResource(this.GetType().Namespace + ".test.xsl")));
XmlReader xtr = new XmlTransformingReader(
new XmlTextReader(
Globals.GetResource(this.GetType().Namespace + ".input.xml")),
tx);
//That's it, now let's dump out XmlTransformingReader to see what it returns
StringWriter sw = new StringWriter();
XmlTextWriter w = new XmlTextWriter(sw);
w.Formatting = Formatting.Indented;
w.WriteNode(xtr, false);
xtr.Close();
w.Close();
Assert.AreEqual(sw.ToString(), @"<parts>
<item SKU=""1001"" name=""Lawnmower"" price=""299.99"" />
<item SKU=""1001"" name=""Electric drill"" price=""99.99"" />
<item SKU=""1001"" name=""Hairdrier"" price=""39.99"" />
</parts>");
}
public static string GenerateIndentedOuterXml(string xmlContent)
{
StringWriter buffer = new StringWriter();
XmlTextWriter writer = new XmlTextWriter(buffer);
writer.Formatting = Formatting.Indented;
writer.WriteNode(new XmlTextReader(new StringReader(xmlContent)), false);
return buffer.ToString();
}
private static void CreateSubdirectoryXML(XmlTextWriter writer, DirectoryInfo dir)
{
string xml = new XElement("dir", new XAttribute("name", dir.Name)).ToString();
XmlReader reader = XmlReader.Create(new StringReader(xml));
writer.WriteNode(reader, true);
foreach (var file in dir.GetFiles())
{
xml = new XElement("file", new XAttribute("name", file.Name)).ToString();
reader = XmlReader.Create(new StringReader(xml));
writer.WriteNode(reader, true);
}
var subdirectories = dir.GetDirectories().ToList().OrderBy(d => d.Name);
foreach (var subDir in subdirectories)
{
CreateSubdirectoryXML(writer, subDir);
}
}
/// <summary>
/// Indents the specifide XML string.
/// </summary>
public static string Indent(this string xml)
{
var reder = new XmlTextReader(new StringReader(xml));
var sw = new StringWriter();
var xmlTextWriter = new XmlTextWriter(sw) {Formatting = Formatting.Indented};
while (reder.Read())
xmlTextWriter.WriteNode(reder, false);
xmlTextWriter.Close();
reder.Close();
return sw.ToString();
}
private static string GetTokenFormatted()
{
var sb = new StringBuilder();
XmlTextWriter w = new XmlTextWriter(new StringWriter(sb));
w.Formatting = Formatting.Indented;
w.IndentChar = '\t';
XmlReader reader = XmlReader.Create(new FileStream(Path.Combine(Application.StartupPath, "token.xml"), FileMode.Open));
w.WriteNode(reader, true);
w.Flush();
return sb.ToString();
}
public void SaveDocument(XmlDocument xmlDocument, string xmlFileName)
{
if (xmlDocument == null) throw new ArgumentNullException("xmlDocument");
if (string.IsNullOrEmpty(xmlFileName)) throw new ArgumentNullException("xmlFileName");
using (var xmlTextReader = new XmlTextReader(xmlDocument.OuterXml, XmlNodeType.Document, new XmlParserContext(null, null, null, XmlSpace.None)))
{
using (var xmlTextWriter = new XmlTextWriter(xmlFileName, Encoding.UTF8))
{
xmlTextWriter.Formatting = Formatting.Indented;
xmlTextWriter.WriteNode(xmlTextReader, true);
xmlTextWriter.Flush();
}
}
}
static void Main(string[] args)
{
bool showHelp = false;
bool suppressOutput = false;
var options = new OptionSet {
{ "s", v => suppressOutput = true },
{ "h|?|help", v => showHelp = true }
};
string filename = options.Parse(args).FirstOrDefault() ?? string.Empty;
if (args.Length == 0 || showHelp)
{
PrintHelp();
return;
}
if(!File.Exists(filename))
{
Console.Error.WriteLine("File {0} does not exist", filename);
return;
}
XmlReader reader;
TextWriter outputStream;
if (suppressOutput)
{
// Suppress output
reader = GetReader(filename);
outputStream = TextWriter.Null;
}
else
{
reader = GetReader(filename);
// Console.Out is a StreamWriter which flushes it's
// buffer after every call to write. This is due to
// setting AutoFlush to true. (according to the docs)
// 256 should be the default buffer size
Console.OpenStandardOutput(256);
outputStream = Console.Out;
}
var writer = new XmlTextWriter(outputStream) {Formatting = Formatting.Indented};
writer.WriteNode(reader, false);
}
public override void TraceData(System.Diagnostics.TraceEventCache eventCache, string source, System.Diagnostics.TraceEventType eventType, int id, object data)
{
// Get ActivityId from the eventCache.
// ActivityId is an internal property. Using reflection to get its value
string activityID = "";
if (eventCache != null)
{
PropertyInfo propInfo = null;
Type objType = eventCache.GetType();
propInfo = objType.GetProperty("ActivityId", BindingFlags.Instance | BindingFlags.GetProperty | BindingFlags.NonPublic);
if (propInfo != null)
{
object value = propInfo.GetValue(eventCache, null);
if (value != null)
activityID = value.ToString();
}
}
Process p = Process.GetProcessById(eventCache.ProcessId);
// Header message that is added by this listener
string msgHeader = string.Format("<HeaderAddedByListener time=\"{0}\" ActivityId=\"{1}\" ProcessId=\"{2}\">", eventCache.DateTime.ToString(), activityID, p.ProcessName);
// Read the message received from wcf
XPathNavigator xPathNavigator = data as XPathNavigator;
if (xPathNavigator == null)
{
return;
}
XmlTextWriter xmlWriter;
StringBuilder msgReceived = new StringBuilder();
xmlWriter = new XmlTextWriter(new System.IO.StringWriter(msgReceived, CultureInfo.CurrentCulture));
xPathNavigator.MoveToRoot();
xmlWriter.WriteNode(xPathNavigator, false);
// Broadcast the msg
string msgToSend = string.Format("{0}{1}</HeaderAddedByListener>", msgHeader, msgReceived.ToString());
GlobalHost.ConnectionManager.GetConnectionContext<ListenerConnection>().Connection.Broadcast(msgToSend);
//base.TraceData(eventCache, source, eventType, id, data);
if (xmlWriter != null)
{
xmlWriter.Close();
}
xmlWriter = null;
msgReceived = null;
}
public static void XPathNodeIteratorToConsole(XPathNodeIterator iterator)
{
Console.WriteLine(new string('-', 50));
XmlTextWriter tw = new XmlTextWriter(Console.Out);
tw.Formatting = Formatting.Indented;
while (iterator.MoveNext())
{
tw.WriteNode(new Mvp.Xml.Common.XPath.XPathNavigatorReader(iterator.Current), false);
}
tw.Flush();
Console.WriteLine();
Console.WriteLine(new string('-', 50));
}
//[STAThread]
public static string Format(string s)
{
var stringWriter = new StringWriter();
var doc = new XmlDocument();
//get your document
doc.LoadXml(s);
//create reader and writer
var xmlReader = new XmlNodeReader(doc);
var xmlWriter = new XmlTextWriter(stringWriter) {Formatting = Formatting.Indented, Indentation = 2, IndentChar = ' '};
//set formatting options
//write the document formatted
xmlWriter.WriteNode(xmlReader, true);
return stringWriter.ToString();
}
internal static void Convert(String htmlFile, String xhtmlFile)
{
using (SgmlReader reader = new SgmlReader()) {
reader.DocType = "HTML";
reader.WhitespaceHandling = WhitespaceHandling.None;
using (StreamReader r = new StreamReader(htmlFile)) {
reader.InputStream = r;
using (XmlTextWriter writer = new XmlTextWriter(xhtmlFile, Encoding.UTF8)) {
writer.Formatting = Formatting.Indented;
reader.Read ();
while (!reader.EOF) {
writer.WriteNode (reader, true);
}
}
}
}
}
public void TestRss()
{
string theWord = "XML";
XPathDocument doc = new XPathDocument("../../Common/XPathIteratorReaderTests/rss.xml");
XPathNodeIterator it = doc.CreateNavigator().Select(
"/rss/channel/item[contains(title,'" + theWord + "')]");
XPathIteratorReader reader = new XPathIteratorReader(it);
reader.MoveToContent();
string xml = reader.ReadOuterXml();
using (StreamWriter sw = new StreamWriter(@"c:\subset.xml", false))
{
XmlTextWriter tw = new XmlTextWriter(sw);
tw.WriteNode(new XPathIteratorReader(it), false);
tw.Close();
}
Assert.IsTrue(xml != String.Empty);
}
/// <summary>
/// 缩进XAML
/// </summary>
/// <param name="xaml"></param>
/// <returns></returns>
public static string IndentXaml(string xaml)
{
//open the string as an XML node
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.LoadXml(xaml);
XmlNodeReader nodeReader = new XmlNodeReader(xmlDoc);
//write it back onto a stringWriter
System.IO.StringWriter stringWriter = new System.IO.StringWriter();
System.Xml.XmlTextWriter xmlWriter = new System.Xml.XmlTextWriter(stringWriter);
xmlWriter.Formatting = System.Xml.Formatting.Indented;
xmlWriter.Indentation = 4;
xmlWriter.IndentChar = ' ';
xmlWriter.WriteNode(nodeReader, false);
string result = stringWriter.ToString();
xmlWriter.Close();
return result;
}
/// <summary>
/// 缩进XAML
/// </summary>
/// <param name="xaml"></param>
/// <returns></returns>
public static string IndentXaml(string xaml)
{
//open the string as an XML node
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.LoadXml(xaml);
XmlNodeReader nodeReader = new XmlNodeReader(xmlDoc);
//write it back onto a stringWriter
System.IO.StringWriter stringWriter = new System.IO.StringWriter();
System.Xml.XmlTextWriter xmlWriter = new System.Xml.XmlTextWriter(stringWriter);
xmlWriter.Formatting = System.Xml.Formatting.Indented;
xmlWriter.Indentation = 4;
xmlWriter.IndentChar = ' ';
xmlWriter.WriteNode(nodeReader, false);
string result = stringWriter.ToString();
xmlWriter.Close();
return(result);
}
public string PrintToString(XmlNode myXmlNode)
{
// write the step node to a stream so that we can get the nice indented formatting for free
XmlNodeReader xnr = new XmlNodeReader(myXmlNode);
MemoryStream myStream = new MemoryStream();
XmlTextWriter xtw = new XmlTextWriter(myStream, System.Text.Encoding.UTF8);
xtw.Formatting = Formatting.Indented;
xtw.WriteNode(xnr, true);
xtw.Flush();
myStream.Position = 0;
StreamReader sr = new StreamReader(myStream, System.Text.Encoding.UTF8);
// copy the new xml to the other box
string myTabbedXmlString = sr.ReadToEnd();
// clean up
sr.Close();
xtw = null;
myStream.Close();
xnr.Close();
return myTabbedXmlString;
}
void RunTest(SgmlReader reader, int line, string args, string input, string expectedOutput)
{
try {
bool testdoc = false;
bool testclone = false;
bool format = true;
bool ignore = false;
foreach(string arg in args.Split(' ')) {
string sarg = arg.Trim();
if(sarg.Length == 0)
continue;
if(sarg[0] == '-') {
switch(sarg.Substring(1)) {
case "html":
reader.DocType = "html";
break;
case "lower":
reader.CaseFolding = CaseFolding.ToLower;
break;
case "upper":
reader.CaseFolding = CaseFolding.ToUpper;
break;
case "testdoc":
testdoc = true;
break;
case "testclone":
testclone = true;
break;
case "noformat":
format = false;
break;
case "ignore":
ignore = true;
break;
}
}
}
this.tests++;
if(ignore) {
this.ignored++;
return;
}
reader.InputStream = new StringReader(input);
if(format) {
reader.WhitespaceHandling = WhitespaceHandling.None;
} else {
reader.WhitespaceHandling = WhitespaceHandling.All;
}
StringWriter output = new StringWriter();
XmlTextWriter w = new XmlTextWriter(output);
if(format) {
w.Formatting = Formatting.Indented;
}
if(testdoc) {
XmlDocument doc = new XmlDocument();
doc.Load(reader);
doc.WriteTo(w);
} else if(testclone) {
XmlDocument doc = new XmlDocument();
doc.Load(reader);
XmlNode clone = doc.Clone();
clone.WriteTo(w);
} else {
reader.Read();
while(!reader.EOF) {
w.WriteNode(reader, true);
}
}
w.Close();
string actualOutput = output.ToString();
// validate output
using(StringReader source = new StringReader(actualOutput)) {
XmlDocument doc = new XmlDocument();
doc.Load(source);
}
// compare output
if(actualOutput.Trim().Replace("\r", "") != expectedOutput.Trim().Replace("\r", "")) {
Console.WriteLine();
Console.WriteLine("ERROR: Test failed on line {0}", line);
Console.WriteLine("---- Expected output");
Console.Write(expectedOutput);
Console.WriteLine("---- Actual output");
Console.WriteLine(actualOutput);
} else {
this.passed++;
}
} catch(Exception e) {
Console.WriteLine("FATAL ERROR: Test threw an exception on line {0}", line);
Console.WriteLine(e.Message);
Console.WriteLine(e.ToString());
Console.WriteLine("---- Input");
Console.Write(input);
}
}
public void WriteNodeError ()
{
XmlTextReader xtr = new XmlTextReader ("<root>", XmlNodeType.Document, null);
xtr.Read ();
try {
xtr.Read ();
} catch {
}
XmlTextWriter xtw = new XmlTextWriter (new StringWriter ());
xtw.WriteNode (xtr, false);
}
/// <summary>
/// Converts the specified html into XHTML compliant text.
/// </summary>
/// <param name="reader">sgml reader.</param>
/// <param name="html">html to convert.</param>
/// <param name="converter">The converter.</param>
/// <returns></returns>
/// ///
private static string ConvertHtmlToXHtml(SgmlReader reader, string html, Converter<string, string> converter)
{
reader.DocType = "html";
reader.WhitespaceHandling = WhitespaceHandling.All;
// Hack to fix SF bug #1678030
html = RemoveNewLineBeforeCDATA(html);
reader.InputStream = new StringReader("<html>" + html + "</html>");
reader.CaseFolding = CaseFolding.ToLower;
StringWriter writer = new StringWriter();
XmlWriter xmlWriter = null;
try
{
xmlWriter = new XmlTextWriter(writer);
bool insideAnchor = false;
bool skipRead = false;
while ((skipRead || reader.Read()) && !reader.EOF)
{
skipRead = false;
switch(reader.NodeType)
{
case XmlNodeType.Element:
//Special case for anchor tags for the time being.
//We need some way to communicate which elements the current node is nested within
if (reader.IsEmptyElement)
{
xmlWriter.WriteStartElement(reader.LocalName);
xmlWriter.WriteAttributes(reader, true);
if (reader.LocalName == "a" || reader.LocalName == "script")
xmlWriter.WriteFullEndElement();
else
xmlWriter.WriteEndElement();
}
else
{
if (reader.LocalName == "a")
insideAnchor = true;
xmlWriter.WriteStartElement(reader.LocalName);
xmlWriter.WriteAttributes(reader, true);
}
break;
case XmlNodeType.Text:
string text = reader.Value;
if (converter != null && !insideAnchor)
xmlWriter.WriteRaw(converter(text));
else
xmlWriter.WriteString(text);
break;
case XmlNodeType.EndElement:
if (reader.LocalName == "a")
insideAnchor = false;
if (reader.LocalName == "a" || reader.LocalName == "script")
xmlWriter.WriteFullEndElement();
else
xmlWriter.WriteEndElement();
break;
default:
xmlWriter.WriteNode(reader, true);
skipRead = true;
break;
}
}
}
finally
{
if (xmlWriter != null)
{
xmlWriter.Close();
}
}
string xml = writer.ToString();
return xml.Substring("<html>".Length, xml.Length - "<html></html>".Length);
}
/// <summary>
/// Converts SGML to XML
/// </summary>
/// <param name="file">OFX File (SGML Format)</param>
/// <returns>OFX File in XML format</returns>
private string SGMLToXML(string file)
{
var reader = new SgmlReader();
//Inititialize SGML reader
reader.InputStream = new StringReader(ParseHeader(file));
reader.DocType = "OFX";
var sw = new StringWriter();
var xml = new XmlTextWriter(sw);
//write output of sgml reader to xml text writer
while (!reader.EOF)
xml.WriteNode(reader, true);
//close xml text writer
xml.Flush();
xml.Close();
var temp = sw.ToString().TrimStart().Split(new[] {'\n', '\r'}, StringSplitOptions.RemoveEmptyEntries);
return String.Join("", temp);
}
/// <summary>
private string GetWellFormedHTML_Handle(string uri)
{
StreamReader sReader = null;
StringWriter sw = null;
SgmlReader reader = null;
XmlTextWriter writer = null;
try
{
if (uri == String.Empty) uri = "http://www.ypshop.net/list--91-940-940--search-1.html";
HttpWebRequest req = (HttpWebRequest)WebRequest.Create(uri);
HttpWebResponse res = (HttpWebResponse)req.GetResponse();
sReader = new StreamReader(res.GetResponseStream());
reader = new SgmlReader();
reader.DocType = "HTML";
reader.InputStream = new StringReader(sReader.ReadToEnd());
sw = new StringWriter();
writer = new XmlTextWriter(sw);
writer.Formatting = Formatting.Indented;
while (reader.Read())
{
if (reader.NodeType != XmlNodeType.Whitespace)
{
writer.WriteNode(reader, true);
}
}
StringBuilder sb = new StringBuilder();
XPathDocument doc = new XPathDocument(new StringReader(sw.ToString()));
XPathNavigator nav = doc.CreateNavigator();
//XPathNodeIterator nodes = nav.Select(xpath);
//while (nodes.MoveNext())
//{
// sb.Append(nodes.Current.Value + " ");
//}
return sb.ToString();
}
catch (Exception exp)
{
writer.Close();
reader.Close();
sw.Close();
sReader.Close();
return exp.Message;
}
}
/// <summary>
/// Creates acquired infoset.
/// </summary>
/// <param name="reader">Source reader</param>
private string CreateAcquiredInfoset(XmlReader reader)
{
//TODO: Try to stream out this stuff
XIncludingReader xir = new XIncludingReader(reader);
xir.XmlResolver = this._xmlResolver;
StringWriter sw = new StringWriter();
XmlTextWriter w = new XmlTextWriter(sw);
try
{
while (xir.Read())
w.WriteNode(xir, false);
}
finally
{
if (xir != null)
xir.Close();
if (w != null)
w.Close();
}
return sw.ToString();
}
/// <summary>
/// Creates acquired infoset.
/// </summary>
private string CreateAcquiredInfoset(Uri includeLocation)
{
if (_cache == null)
_cache = new Dictionary<string, WeakReference>();
WeakReference wr;
if (_cache.TryGetValue(includeLocation.AbsoluteUri, out wr) && wr.IsAlive)
{
return (string)wr.Target;
}
else
{
//Not cached or GCollected
WebResponse wRes;
Stream stream = GetResource(includeLocation.AbsoluteUri,
_reader.GetAttribute(_keywords.Accept),
_reader.GetAttribute(_keywords.AcceptLanguage), out wRes);
XIncludingReader xir = new XIncludingReader(wRes.ResponseUri.AbsoluteUri, stream, _nameTable);
xir.WhitespaceHandling = _whiteSpaceHandling;
StringWriter sw = new StringWriter();
XmlTextWriter w = new XmlTextWriter(sw);
try
{
while (xir.Read())
w.WriteNode(xir, false);
}
finally
{
if (xir != null)
xir.Close();
if (w != null)
w.Close();
}
string content = sw.ToString();
lock (_cache)
{
if (!_cache.ContainsKey(includeLocation.AbsoluteUri))
_cache.Add(includeLocation.AbsoluteUri, new WeakReference(content));
}
return content;
}
}
/// <summary>See <see cref="XmlReader.ReadOuterXml"/></summary>
public override string ReadOuterXml()
{
switch (_state)
{
case XIncludingReaderState.ExposingXmlBaseAttr:
return @"xml:base="" + _reader.BaseURI + @""";
case XIncludingReaderState.ExposingXmlBaseAttrValue:
return String.Empty;
case XIncludingReaderState.ExposingXmlLangAttr:
return @"xml:lang="" + _reader.XmlLang + @""";
case XIncludingReaderState.ExposingXmlLangAttrValue:
return String.Empty;
default:
if (NodeType == XmlNodeType.Element)
{
StringWriter sw = new StringWriter();
XmlTextWriter xw = new XmlTextWriter(sw);
xw.WriteNode(this, false);
xw.Close();
return sw.ToString();
}
else if (NodeType == XmlNodeType.Attribute)
{
return String.Format("{0=\"{1}\"}", Name, Value);
}
else
return String.Empty;
}
}
public override string ReadInnerXml() {
StringWriter sw = new StringWriter();
XmlTextWriter xw = new XmlTextWriter(sw);
xw.Formatting = Formatting.Indented;
switch (this.NodeType) {
case XmlNodeType.Element:
Read();
while (!this.EOF && this.NodeType != XmlNodeType.EndElement) {
xw.WriteNode(this, true);
}
Read(); // consume the end tag
break;
case XmlNodeType.Attribute:
sw.Write(this.Value);
break;
default:
// return empty string according to XmlReader spec.
break;
}
xw.Close();
return sw.ToString();
}
public override string ReadOuterXml() {
StringWriter sw = new StringWriter();
XmlTextWriter xw = new XmlTextWriter(sw);
xw.Formatting = Formatting.Indented;
xw.WriteNode(this, true);
xw.Close();
return sw.ToString();
}
public static string StandardizationHTML(string html, bool isClearCommentary, bool isClearScript, bool isClearStyle, bool isReplenishHtmlTag)
{
if (html.Trim() == "")
{
return "";
}
if (isReplenishHtmlTag)
{
string str = html.ToUpper();
if (!str.StartsWith("<HTML"))
{
int index = str.IndexOf("<HTML");
if (index > 0)
{
html = html.Substring(index, str.Length - index);
}
else
{
html = "<HTML>" + html;
}
}
str = html.ToUpper();
if (!str.EndsWith("</HTML>"))
{
int length = str.LastIndexOf("</HTML>");
if (length > 0)
{
html = html.Substring(0, length) + "</HTML>";
}
else
{
html = html + "</HTML>";
}
}
}
Shove.HTML.SgmlReader.SgmlReader reader = new Shove.HTML.SgmlReader.SgmlReader();
reader.DocType = "HTML";
reader.InputStream = new StringReader(html);
reader.CaseFolding = CaseFolding.ToUpper;
reader.WhitespaceHandling = WhitespaceHandling.None;
StringWriter w = new StringWriter();
XmlTextWriter writer2 = new XmlTextWriter(w);
writer2.Formatting = Formatting.Indented;
string str2 = "";
try
{
while (reader.Read())
{
if (reader.NodeType != XmlNodeType.Whitespace)
{
writer2.WriteNode(reader, true);
}
}
}
catch
{
}
str2 = w.ToString();
if (isClearCommentary && (str2 != ""))
{
str2 = ClearCommentary(str2);
}
if (isClearScript && (str2 != ""))
{
str2 = ClearScript(str2);
}
if (isClearStyle && (str2 != ""))
{
str2 = ClearStyle(str2);
}
if ((!isClearCommentary && !isClearScript) && !isClearStyle)
{
return str2;
}
return StandardizationHTML(str2, false, false, false, isReplenishHtmlTag);
}
/// <summary>
/// Initializes the task and verifies parameters.
/// </summary>
/// <param name="TaskNode">Node that contains the XML fragment used to define this task instance.</param>
protected override void InitializeTask(XmlNode TaskNode)
{
XmlElement taskXml = (XmlElement) TaskNode.Clone();
// Expand all properties in the task and its child elements
if (taskXml.ChildNodes != null) {
ExpandPropertiesInNodes(taskXml.ChildNodes);
if (taskXml.Attributes != null) {
foreach (XmlAttribute attr in taskXml.Attributes) {
attr.Value = Properties.ExpandProperties(attr.Value, Location);
}
}
}
// Get the [SchemaValidator(type)] attribute
SchemaValidatorAttribute[] taskValidators =
(SchemaValidatorAttribute[])GetType().GetCustomAttributes(
typeof(SchemaValidatorAttribute), true);
if (taskValidators.Length > 0) {
SchemaValidatorAttribute taskValidator = taskValidators[0];
XmlSerializer taskSerializer = new XmlSerializer(taskValidator.ValidatorType);
// get embedded schema resource stream
Stream schemaStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(
taskValidator.ValidatorType.Namespace);
// ensure schema resource was embedded
if (schemaStream == null) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Schema resource '{0}' could not be found.",
taskValidator.ValidatorType.Namespace), Location);
}
// load schema resource
XmlTextReader tr = new XmlTextReader(
schemaStream, XmlNodeType.Element, null);
// Add the schema to a schema collection
XmlSchema schema = XmlSchema.Read(tr, null);
XmlSchemaCollection schemas = new XmlSchemaCollection();
schemas.Add(schema);
string xmlNamespace = (taskValidator.XmlNamespace != null ? taskValidator.XmlNamespace : GetType().FullName);
// Create a namespace manager with the schema's namespace
NameTable nt = new NameTable();
XmlNamespaceManager nsmgr = new XmlNamespaceManager(nt);
nsmgr.AddNamespace(string.Empty, xmlNamespace);
// Create a textreader containing just the Task's Node
XmlParserContext ctx = new XmlParserContext(
null, nsmgr, null, XmlSpace.None);
taskXml.SetAttribute("xmlns", xmlNamespace);
XmlTextReader textReader = new XmlTextReader(taskXml.OuterXml,
XmlNodeType.Element, ctx);
// Copy the node from the TextReader and indent it (for error
// reporting, since NAnt does not retain formatting during a load)
StringWriter stringWriter = new StringWriter();
XmlTextWriter textWriter = new XmlTextWriter(stringWriter);
textWriter.Formatting = Formatting.Indented;
textWriter.WriteNode(textReader, true);
//textWriter.Close();
XmlTextReader formattedTextReader = new XmlTextReader(
stringWriter.ToString(), XmlNodeType.Document, ctx);
// Validate the Task's XML against its schema
XmlValidatingReader validatingReader = new XmlValidatingReader(
formattedTextReader);
validatingReader.ValidationType = ValidationType.Schema;
validatingReader.Schemas.Add(schemas);
validatingReader.ValidationEventHandler +=
new ValidationEventHandler(Task_OnSchemaValidate);
while (validatingReader.Read()) {
// Read strictly for validation purposes
}
validatingReader.Close();
if (!_validated) {
// Log any validation errors that have ocurred
for (int i = 0; i < _validationExceptions.Count; i++) {
BuildException ve = (BuildException) _validationExceptions[i];
if (i == _validationExceptions.Count - 1) {
// If this is the last validation error, throw it
throw ve;
}
Log(Level.Info, ve.Message);
}
}
NameTable taskNameTable = new NameTable();
XmlNamespaceManager taskNSMgr = new XmlNamespaceManager(taskNameTable);
taskNSMgr.AddNamespace(string.Empty, xmlNamespace);
XmlParserContext context = new XmlParserContext(
null, taskNSMgr, null, XmlSpace.None);
XmlTextReader taskSchemaReader = new XmlTextReader(
taskXml.OuterXml, XmlNodeType.Element, context);
// Deserialize from the Task's XML to the schema wrapper object
_schemaObject = taskSerializer.Deserialize(taskSchemaReader);
}
}
/// <summary>
/// 读取html页面内容
/// </summary>
/// <param name="uri">网址</param>
/// <param name="xpath">xpath标签</param>
/// <returns></returns>
private string GetWellFormedHTML(string uri, string xpath)
{
StreamReader sReader = null;//读取字节流
StringWriter sw = null;//写入字符串
SgmlReader reader = null;//sgml读取方法
XmlTextWriter writer = null;//生成xml数据流
try
{
if (uri == String.Empty)
uri = "http://www.ypshop.net/list--91-940-940--search-1.html";
WebClient webclient = new WebClient();
webclient.Encoding = Encoding.UTF8;
//页面内容
string strWebContent = webclient.DownloadString(uri);
reader = new SgmlReader();
reader.DocType = "HTML";
reader.InputStream = new StringReader(strWebContent);
sw = new StringWriter();
writer = new XmlTextWriter(sw);
writer.Formatting = Formatting.Indented;
while (reader.Read())
{
if (reader.NodeType != XmlNodeType.Whitespace)
{
writer.WriteNode(reader, true);
}
}
//return sw.ToString();
if (xpath == null)
{
return sw.ToString();
}
else
{ //Filter out nodes from HTML
StringBuilder sb = new StringBuilder();
XPathDocument doc = new XPathDocument(new StringReader(sw.ToString()));
XPathNavigator nav = doc.CreateNavigator();
XPathNodeIterator nodes = nav.Select(xpath);
while (nodes.MoveNext())
{
sb.Append(nodes.Current.Value + " ");
}
return sb.ToString();
}
}
catch (Exception exp)
{
writer.Close();
reader.Close();
sw.Close();
sReader.Close();
return exp.Message;
}
}
