Html解析神器 HtmlAgilityPack

HtmlAgilityPack 之 HtmlNode類

HtmlAgilityPack中的HtmlNode類與XmlNode類差不多，提供的功能也大同小異。下面來看看該類提供功能。

一、靜態屬性

public static Dictionary<string, HtmlElementFlag> //ElementsFlags;獲取集合的定義爲特定的元素節點的特定行爲的標誌。表包含小寫標記名稱作爲鍵和作爲值的 HtmlElementFlags 組合 DictionaryEntry 列表。
public static readonly string HtmlNodeTypeNameComment;　　//獲取一個註釋節點的名稱。實際上，它被定義爲 '#comment
public static readonly string HtmlNodeTypeNameDocument;　  //獲取文檔節點的名稱。實際上，它被定義爲 '#document'
public static readonly string HtmlNodeTypeNameText;　　　　  //獲取一個文本節點的名稱。實際上，它被定義爲 '#text'

二、屬性

Attributes 　　　　　　　　　　　　獲取節點的屬性集合
ChildNodes　　　　　　　　　　　　獲取子節點集合(包括文本節點)
Closed　　　　　　　　　　　　　　該節點是否已關閉(</xxx>)
ClosingAttributes　　　　　　　　  在關閉標籤的屬性集合
FirstChild　　　　　　　　　　　　  獲取第一個子節點
HasAttributes　　　　　　　　　　  判斷該節點是否含有屬性
HasChildNodes　　　　　　　　　　判斷該節點是否含有子節點
HasClosingAttributes　　　　　　  判斷該節點的關閉標籤是否含有屬性(</xxx class="xxx">)
Id　　　　　　　　　　　　　　　　 獲取該節點的Id屬性
InnerHtml　　　　　　　　　　　　 獲取該節點的Html代碼
InnerText　　　　　　　　　　　　 獲取該節點的內容，與InnerHtml不同的地方在於它會過濾掉Html代碼，而InnerHtml是連Html代碼一起輸出
LastChild　　　　　　　　　　　　  獲取最後一個子節點
Line　　　　　　　　　　　　　　　 獲取該節點的開始標籤或開始代碼位於整個HTML源代碼的第幾行(行號)
LinePosition　　　　　　　　　　　 獲取該節點位於第幾列
Name　　　　　　　　　　　　　　  Html元素名
NextSibling　　　　　　　　　　　　獲取下一個兄弟節點
NodeType　　　　　　　　　　　　  獲取該節點的節點類型
OriginalName　　　　　　　　　　　獲取原始的未經更改的元素名
OuterHtml　　　　　　　　　　　　 整個節點的代碼
OwnerDocument　　　　　　　　　節點所在的HtmlDocument文檔
ParentNode　　　　　　　　　　　　獲取該節點的父節點
PreviousSibling　　　　　　　　　　獲取前一個兄弟節點
StreamPosition　　　　　　　　　　該節點位於整個Html文檔的字符位置
XPath　　　　　　　　　　　　　　  根據節點返回該節點的XPath

代碼示例：

static void Main(string[] args)
        {
            //<ul class="user_match clear">
            //    <li>年齡：21～30之間</li>
            //    <li>婚史：未婚</li>
            //    <li>地區：不限</li>
            //    <li>身高：175～185釐米之間</li>
            //    <li>學歷：不限</li>
            //    <li>職業：不限</li>
            //    <li>月薪：不限</li>
            //    <li>住房：不限</li>
            //    <li>購車：不限</li>
            //</ul>


            WebClient wc = new WebClient();
            wc.BaseAddress = "http://www.juedui100.com/";
            wc.Encoding = Encoding.UTF8;
            HtmlDocument doc = new HtmlDocument();
            string html = wc.DownloadString("user/6971070.html");
            doc.LoadHtml(html);
            HtmlNode node = doc.DocumentNode.SelectSingleNode("/html/body/div[4]/div[1]/div[2]/ul[1]");     //根據XPath查找節點，跟XmlNode差不多
            Console.WriteLine(node.InnerText);  //輸出節點內容      年齡：21～30之間 婚史：未婚 ......      與InnerHtml的區別在於，它不會輸出HTML代碼
            Console.WriteLine(node.InnerHtml);  //輸出節點Html <li>年齡：21～30之間</li> <li>婚史：未婚</li> ....
            Console.WriteLine(node.Name);       //輸出 ul    Html元素名 

            HtmlAttributeCollection attrs = node.Attributes;
            foreach(var item in attrs)
            {
                Console.WriteLine(item.Name + " : " + item.Value);    //輸出 class ：user_match clear
            }

            HtmlNodeCollection CNodes = node.ChildNodes;    //所有的子節點
            foreach (HtmlNode item in CNodes)
            {
                Console.WriteLine(item.Name + "-" + item.InnerText);  //輸出 li-年齡：21～30之間#text-   li-婚史：未婚#text-     .......  別忘了文本節點也算
            }

            Console.WriteLine(node.Closed);     //輸出True    //當前的元素節點是否已封閉

            Console.WriteLine("================================");

            HtmlAttributeCollection attrs1 = node.ClosingAttributes;    //獲取在結束標記的 HTML 屬性的集合。  例如</ul class="">
            Console.WriteLine(attrs1.Count);    //輸出0

            HtmlNode node1 = node.FirstChild;   //悲劇了ul的第一個節點是一個 \n 換行文本節點 第二個節點纔到第一個li
            Console.WriteLine(node1.NodeType);  //輸出Text 文本節點
            HtmlNode node3 = node.LastChild;    //同樣最後一個節點一樣是 \n 文本節點
            Console.WriteLine(node3.NodeType);  //輸出Text 文本節點

            HtmlNode node2 = node.SelectSingleNode("child::li[1]");     //獲取當前節點的第一個子li節點
            Console.WriteLine(node2.XPath);     //根據節點生成XPath表達式  /html/body/div[4]/div[1]/div[2]/ul[1]/li[1]   媽了個B，強大

            Console.WriteLine(node.HasAttributes);          //輸出 True   判斷節點是否含有屬性
            Console.WriteLine(node.HasChildNodes);          //輸出 True   判斷節點是否含有子節點
            Console.WriteLine(node.HasClosingAttributes);   //False     判斷節點結束標記是否含有屬性
            
            Console.WriteLine(node.Line);           //輸出 155  該節點開始標記位於頁面代碼的第幾行
            Console.WriteLine(node.LinePosition);   //輸出 1   該節點開始標記位於第幾列2
            Console.WriteLine(node.NodeType);       //輸出 Element   該節點類型 此處爲元素節點            
            Console.WriteLine(node.OriginalName);   //輸出 ul
            HtmlNode node4 = node.SelectSingleNode("child::li[1]");
            Console.WriteLine(node4.InnerText);     //輸出 年齡：21～30之間
            HtmlNode node5 = node4.NextSibling.NextSibling;     //獲取下一個兄弟元素 因爲有一個換行符的文本節點，因此要兩次，跳過換行那個文本節點
            Console.WriteLine(node5.InnerText);     //輸出 婚史:未婚
            HtmlNode node6 = node5.PreviousSibling.PreviousSibling;     //同樣兩次以跳過換行文本節點
            Console.WriteLine(node6.InnerText);     //輸出 年齡：21～30之間
            HtmlNode node7 = node6.ParentNode;      //獲取父節點
            Console.WriteLine(node7.Name);          //輸出 ul
            string str = node.OuterHtml;
            Console.WriteLine(str);     //輸出整個ul代碼class="user_match clear"><li>年齡：21～30之間</li>...</ul>
            Console.WriteLine(node.StreamPosition); //輸出7331    獲取此節點的流位置在文檔中，相對於整個文檔(Html頁面源代碼)的開始。
            HtmlDocument doc1 = node.OwnerDocument;
            doc1.Save(@"D:\123.html");

            HtmlNode node8 = doc.DocumentNode.SelectSingleNode("//*[@id=\"coll_add_aid59710701\"]");
            //<a id="coll_add_aid59710701" style="display:block" class="coll_fix needlogin" href="javascript:coll_add(5971070)">收藏</a>
            Console.WriteLine(node8.Id);    //輸出 coll_add_aid59710701   獲取Id屬性的內容

            Console.ReadKey();
        }

三、方法

IEnumerable<HtmlNode> Ancestors(); 　　　　　　　　　　　　　　返回此元素的所有上級節點的集合。
IEnumerable<HtmlNode> Ancestors(string name); 　　　　 　　　  返回此元素參數名字匹配的所有上級節點的集合。
IEnumerable<HtmlNode> AncestorsAndSelf(); 　　　　　　 　　　　返回此元素的所有上級節點和自身的集合。
IEnumerable<HtmlNode> AncestorsAndSelf(string name); 　　　　 返回此元素的名字匹配的所有上級節點和自身的集合。
HtmlNode AppendChild(HtmlNode newChild); 　　　　　　 　　　　  將參數元素追加到爲調用元素的子元素(追加在最後)
void AppendChildren(HtmlNodeCollection newChildren);　　　　　　 將參數集合中的元素追加爲調用元素的子元素(追加在最後)
HtmlNode PrependChild(HtmlNode newChild); 　　　　　　　　　　   將參數中的元素作爲子元素，放在調用元素的最前面
void PrependChildren(HtmlNodeCollection newChildren); 　　　　　　將參數集合中的所有元素作爲子元素，放在調用元素前面
static bool CanOverlapElement(string name); 　　　　　　　　　　　 確定是否可以保存重複的元素
IEnumerable<HtmlAttribute> ChildAttributes(string name); 　　　　獲取所有子元素的屬性(參數名要與元素名匹配)
HtmlNode Clone(); 　　　　　　　　　　　　　　　　　　　　　　　　 本節點克隆到一個新的節點
HtmlNode CloneNode(bool deep); 　　　　　　　　　　　　　　　　　節點克隆到一個新的幾點，參數確定是否連子元素一起克隆
HtmlNode CloneNode(string newName); 　　　　　　　　　　　　　　克隆的同時更改元素名
HtmlNode CloneNode(string newName, bool deep);　　　　　　　　  克隆的同時更改元素名。參數確定是否連子元素一起克隆
void CopyFrom(HtmlNode node); 　　　　　　　　　　　　　　　　　 創建重複的節點和其下的子樹。
void CopyFrom(HtmlNode node, bool deep); 　　　　　　　　　　　 創建節點的副本。
XPathNavigator CreateNavigator(); 　　　　　　　　　　　　　　　　 返回的一個對於此文檔的XPathNavigator
static HtmlNode CreateNode(string html); 　　　　　　　　　　　　  靜態方法，允許用字符串創建一個新節點
XPathNavigator CreateRootNavigator(); 　　　　　　　　　　　　　　創建一個根路徑的XPathNavigator
IEnumerable<HtmlNode> DescendantNodes(); 　　　　　　　　　　 獲取所有子代節點
IEnumerable<HtmlNode> DescendantNodesAndSelf(); 　　　　　　 獲取所有的子代節點以及自身
IEnumerable<HtmlNode> Descendants(); 　　　　　　　　　　　　　獲取枚舉列表中的所有子代節點
IEnumerable<HtmlNode> Descendants(string name); 　　　　　　　獲取枚舉列表中的所有子代節點，注意元素名要與參數匹配
IEnumerable<HtmlNode> DescendantsAndSelf(); 　　　　　　　　　獲取枚舉列表中的所有子代節點以及自身
IEnumerable<HtmlNode> DescendantsAndSelf(string name);　　　 獲取枚舉列表中的所有子代節點以及自身，注意元素名要與參數匹配
HtmlNode Element(string name); 　　　　　　　　　　　　　　　　　 根據參數名獲取一個元素
IEnumerable<HtmlNode> Elements(string name); 　　　　　　　　　根據參數名獲取匹配的元素集合
bool GetAttributeValue(string name, bool def); 　　　　　　　　　　 幫助方法，用來獲取此節點的屬性的值(布爾類型)。如果未找到該屬性，則將返回默認值。
int GetAttributeValue(string name, int def); 　　　　　　　　　　　　 幫助方法，用來獲取此節點的屬性的值(整型)。如果未找到該屬性，則將返回默認值。
string GetAttributeValue(string name, string def); 　　　　　　　　　幫助方法，用來獲取此節點的屬性的值(字符串類型)。如果未找到該屬性，則將返回默認值。
HtmlNode InsertAfter(HtmlNode newChild, HtmlNode refChild); 　　  將一個節點插入到第二個參數節點的後面，與第二個參數是兄弟關係
HtmlNode InsertBefore(HtmlNode newChild, HtmlNode refChild); 　　講一個節點插入到第二個參數節點的後面，與第二個參數是兄弟關係
static bool IsCDataElement(string name); 　　　　　　　　　　　　　 確定是否一個元素節點是一個 CDATA 元素節點。
static bool IsClosedElement(string name); 　　　　　　　　　　　　　確定是否封閉的元素節點
static bool IsEmptyElement(string name); 　　　　　　　　　　　　   確定是否一個空的元素節點。
static bool IsOverlappedClosingElement(string text); 　　　　　　　  確定是否文本對應於一個節點可以保留重疊的結束標記。
void Remove(); 　　　　　　　　　　　　　　　　　　　　　　　　　　 從父集合中移除調用節點
void RemoveAll(); 　　　　　　　　　　　　　　　　　　　　　　　　　 移除調用節點的所有子節點以及屬性
void RemoveAllChildren(); 　　　　　　　　　　　　　　　　　　　　　 移除調用節點的所有子節點
HtmlNode RemoveChild(HtmlNode oldChild); 　　　　　　　　　　　　 移除調用節點的指定名字的子節點
HtmlNode RemoveChild(HtmlNode oldChild, bool keepGrandChildren);移除調用節點調用名字的子節點，第二個參數確定是否連孫子節點一起移除
HtmlNode ReplaceChild(HtmlNode newChild, HtmlNode oldChild);　　 將調用節點原有的一個子節點替換爲一個新的節點，第二個參數是舊節點
HtmlNodeCollection SelectNodes(string xpath);　　　　　　　　　　　根據XPath獲取一個節點集合
HtmlNode SelectSingleNode(string xpath); 　　　　　　　　　　　　　根據XPath獲取唯一的一個節點
HtmlAttribute SetAttributeValue(string name, string value); 　　　　 設置調用節點的屬性
string WriteContentTo(); 　　　　　　　　　　　　　　　　　　　　　  將該節點的所有子級都保存到一個字符串中。
void WriteContentTo(TextWriter outText); 　　　　　　　　　　　　　將該節點的所有子級都保存到指定的 TextWriter。
string WriteTo(); 　　　　　　　　　　　　　　　　　　　　　　　　　　將當前節點保存到一個字符串中。
void WriteTo(TextWriter outText); 　　　　　　　　　　　　　　　　　將當前節點保存到指定的 TextWriter。
void WriteTo(XmlWriter writer); 　　　　　　　　　　　　　　　　　　  將當前節點保存到指定的則 XmlWriter。

　　示例代碼：

        static void Main(string[] args)
        {
            //<ul class="user_match clear">
            //    <li>年齡：21～30之間</li>
            //    <li>婚史：未婚</li>
            //    <li>地區：不限</li>
            //    <li>身高：175～185釐米之間</li>
            //    <li>學歷：不限</li>
            //    <li>職業：不限</li>
            //    <li>月薪：不限</li>
            //    <li>住房：不限</li>
            //    <li>購車：不限</li>
            //</ul>


            WebClient wc = new WebClient();
            wc.BaseAddress = "http://www.juedui100.com/";
            wc.Encoding = Encoding.UTF8;
            HtmlDocument doc = new HtmlDocument();
            string html = wc.DownloadString("user/6971070.html");
            doc.LoadHtml(html);
            HtmlNode node = doc.DocumentNode.SelectSingleNode("/html/body/div[4]/div[1]/div[2]/ul[1]");     //根據XPath查找節點，跟XmlNode差不多

            IEnumerable<HtmlNode> nodeList = node.Ancestors();  //獲取該元素所有的父節點的集合
            foreach (HtmlNode item in nodeList)
            {
                Console.Write(item.Name + " ");   //輸出 div div body html #document
            }
            Console.WriteLine();

            IEnumerable<HtmlNode> nodeList1 = node.Ancestors("body");  //獲取名字匹配的該元素的父集合,其實參數就是一個篩選的功能
            foreach (HtmlNode item in nodeList1)
            {
                Console.Write(item.Name + " ");   //輸出 body
            }
            Console.WriteLine();

            IEnumerable<HtmlNode> nodeList2 = node.AncestorsAndSelf();  //獲取所有的父節點和自身
            foreach (HtmlNode item in nodeList2)
            {
                Console.Write(item.Name + " "); //輸出 ul div div div body html #document
            }
            Console.WriteLine();

            IEnumerable<HtmlNode> nodeList3 = node.AncestorsAndSelf("div");     //獲取父節點和自身，參數用於篩選
            foreach (HtmlNode item in nodeList3)
            {
                Console.Write(item.Name + " "); //輸出 div div div
            }
            Console.WriteLine();

            HtmlNode node1 = doc.CreateElement("li");
            node1.InnerHtml = "我是附加的li元素";
            node.AppendChild(node1);    //...<li>購車：不限</li> 後面加了一個<li>我是附加的li元素</li>
            Console.WriteLine(node.InnerHtml);


            HtmlNode node2 = doc.CreateElement("li");
            node2.InnerHtml = "新li一";
            HtmlNode node3 = doc.CreateElement("li");
            node3.InnerHtml = "新li二";
            HtmlNodeCollection nc = new HtmlNodeCollection(node2);
            nc.Add(node2);
            nc.Add(node3);
            node.AppendChildren(nc);    //一次過追加多個元素
            Console.WriteLine(node.InnerHtml);      //...<li>我是附加的li元素</li><li>新li一</li><li>新li二</li>

            Console.WriteLine(HtmlNode.CanOverlapElement("node2"));     //輸出False   確定是否可以保存一個重複的元素

            IEnumerable<HtmlAttribute> attrs = node.ChildAttributes("class");   //獲取子節點與自身的所有名爲class的屬性集合
            foreach (HtmlAttribute attr in attrs)
            {
                Console.Write(attr.Value);      //輸出 user_match clear 
            }

            HtmlNode node4 = node.Clone();
            Console.WriteLine(node4.InnerHtml);     //輸出node的代碼，node已被複制到了node

            HtmlNode node5 = node.CloneNode(false); //參數決定是否複製子節點，與XmlNode一樣
            Console.WriteLine(node5.OuterHtml);     //<ul class="user_match clear"></ul>    因爲參數設爲了false子節點沒有被複制

            HtmlNode node6 = node.CloneNode("div");    //複製節點的同時，更改名字
            Console.WriteLine(node6.OuterHtml);        //輸出 <div class="user_match clear"><li>年齡：21～30之間</li>...</div>  ul已被改爲了div

            HtmlNode node7 = node.CloneNode("table",false);
            Console.WriteLine(node7.OuterHtml);        //輸出<table class="user_match clear"></table>     參數爲false所以沒有複製子節點

            HtmlNode node8 = node.SelectSingleNode("child::li[1]");
            node.CopyFrom(node);
            Console.WriteLine(node.OuterHtml);
            Console.WriteLine("========================");
            //public void CopyFrom(HtmlNode node);
            //public void CopyFrom(HtmlNode node, bool deep);
            //public XPathNavigator CreateNavigator();
            //public XPathNavigator CreateRootNavigator();

            HtmlNode node9 = HtmlNode.CreateNode("<li>新節點</li>");   //直接用字符串創建節點，還是挺好用的
            Console.WriteLine(node9.OuterHtml);     //輸出 <li>新節點</li>

            IEnumerable<HtmlNode> nodeList4 = node.DescendantNodes();   //獲取所有的子節點集合
            foreach (HtmlNode item in nodeList4)
            {
                Console.Write(item.OuterHtml);      //輸出 node的每個子li節點
            }
            Console.WriteLine("===================");

            IEnumerable<HtmlNode> nodeList5 = node.DescendantNodesAndSelf();
            foreach (HtmlNode item in nodeList5)
            {
                Console.Write(item.OuterHtml);      //輸出自身<ul>..包括子節點<li>...</li></ul> 再輸出所有的子li節點
            }
            Console.WriteLine();

            IEnumerable<HtmlNode> nodeList6 = node.DescendantNodes();   //獲取枚舉列表中的所有子代節
            foreach (HtmlNode item in nodeList6)
            {
                Console.Write(item.InnerText);  //輸出所有的li節點的內容
            }
            Console.WriteLine("---------------");

            IEnumerable<HtmlNode> nodeList7 = node.Descendants("li");   //獲取所有的子後代元素    //文本節點不在此範圍內
            foreach(HtmlNode item in nodeList7)
            {
                Console.Write(item.InnerText);   
            }

            IEnumerable<HtmlNode> nodeList8 = node.DescendantsAndSelf("ul");   //獲取所有的子後代元素    //文本節點不在此範圍內
            foreach (HtmlNode item in nodeList8)
            {
                Console.Write(item.Name);       //輸出 ul 參數實際上只相當於過濾的作用
            }

            HtmlNode node10 = node.Element("li");   //獲取第一個子節點名稱匹配的元素
            Console.WriteLine(node10.InnerText);        //輸出 年齡：年齡：21～30之間
            Console.WriteLine("----------------------------------------");

            IEnumerable<HtmlNode> nodeList9 = node.Elements("li");
            foreach (HtmlNode item in nodeList9)
            {
                Console.Write(item.InnerText);      //輸出 所有的li節點內容
            }
            Console.WriteLine();

            //換一個新的，好像有點亂了
            HtmlNode newnode = doc.DocumentNode.SelectSingleNode("/html/body/div[4]/div[1]/div[3]");
            //<div class="col say">
            //    <h3>愛情獨白</h3>
            //    <p>願得一心人，白首不相離。我一直相信我的另一半就在茫茫人海中，有一天一定會與我相遇。</p>
            //</div>

            //bool b = newnode.GetAttributeValue("class", false);   //獲取一個布爾值的屬性,沒有找到則返回第二個參數的默認值
            //Console.WriteLine(b);
            //int i = newnode.GetAttributeValue("class", 0);        //獲取一個整形的屬性，沒有找到則返回第二個參數的默認值
            //Console.WriteLine(i);

            string str = newnode.GetAttributeValue("class", "");    //獲取一個字符串屬性
            Console.WriteLine(str); //輸出 col say

            HtmlNode node11 = HtmlNode.CreateNode("<b>我是加粗節點</b>");
            HtmlNode node12 = newnode.SelectSingleNode("h3");
            newnode.InsertAfter(node11, node12);    //意思是在node12代表的h3節點後面插入node11節點
            Console.WriteLine(newnode.InnerHtml);   //h3>愛情獨白</h3><b>我是加粗節點</b><p>願得一心人...      留意到b節點已經被插入到h3後面

            newnode.InsertBefore(node11, node12);   //再插入多一次，方法不同罷了，這次是在node12帶包的h3前面插入
            Console.WriteLine(newnode.InnerHtml);   //<b>我是加粗節點</b><h3>愛情獨白</h3><b>我是加粗節點</b><p>願得一心人

            Console.WriteLine("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
            newnode.RemoveChild(node11);    //移除了第一個<b>我是加粗節點</b>   此方法的重載，第二個參數決定是否移除孫子節點
            Console.WriteLine(newnode.InnerHtml);   //<h3>愛情獨白</h3><b>我是加粗節點</b><p>願得一心人....

            newnode.RemoveAllChildren();        //移除所有子節點
            Console.WriteLine(newnode.OuterHtml);   //<div class="col say"></div>   所有子節點都被移除了

            newnode.RemoveAll();                    //移除所有的屬性和子節點，由於子節點已經被上個方法移除了，因此這次連屬性也移除了
            Console.WriteLine(newnode.OuterHtml);   //輸出 <div></div>    注意到屬性也被移除了。

            //都移除光了，再來一個，還是剛纔那個
            HtmlNode newnode1 = doc.DocumentNode.SelectSingleNode("/html/body/div[4]/div[1]/div[3]");
            Console.WriteLine("===================");
            Console.WriteLine(newnode1.OuterHtml);  //輸出 <div></div>    注意 移除是從HtmlDocument中移除的，再次獲取獲取不到了

            HtmlNode newnode2 = doc.DocumentNode.SelectSingleNode("/html/body/div[4]/div[1]/div[2]/div[2]/p");
            Console.WriteLine(newnode2.OuterHtml);
            //<p class="no_tip">她還沒有設置不能忍受清單　
            //    <a href="javascript:invite(5971070,8,'邀請設置不能忍受');" class="link_b needlogin">邀請她設置</a>
            //</p>
            newnode2.Remove();    //從文檔樹中移除newnode2節點
            HtmlNode newnode3 = doc.DocumentNode.SelectSingleNode("/html/body/div[4]/div[1]/div[2]/div[2]/p");   //再次獲取該節點
            //Console.WriteLine(newnode3.OuterHtml);  //報未將對象引用到對象的實例異常，明顯是找不到了，

            HtmlNode newnode4 = doc.DocumentNode.SelectSingleNode("/html/body/div[4]/div[1]/div[1]/div/div[1]/p[2]/b[1]");
            Console.WriteLine(newnode4.OuterHtml);
            //<b>相冊：
            //    <a href="/photo/6971070.html" class="red">4</a>張
            //</b>
            HtmlNode node17 = HtmlNode.CreateNode("<div>再次創建一個節點</div>");
            newnode4.PrependChild(node17);      //跟AppengChild類似，只是插入位置不同PrependChildren接受一個節點集合，一次過插入多個節點而已
            Console.WriteLine(newnode4.OuterHtml);  
            //輸出
            //<b>相冊：
            //    <div>再次創建一個節點</div>
            //    <a href="/photo/6971070.html" class="red">4</a>張
            //</b>
            HtmlNode node16 = newnode4.SelectSingleNode("child::a[1]");
            HtmlNode node18 = HtmlNode.CreateNode("<p>新建一行</p>");
            newnode4.ReplaceChild(node18, node16);
            Console.WriteLine(newnode4.OuterHtml);
            //輸出
            //<b>相冊：
            //    <div>再次創建一個節點</div>
            //    <p>新建一行</p>張      //留意到node16代表得節點已經被替換掉了
            //</b>

            HtmlNode node19 = newnode4.SelectSingleNode("child::p[1]");
            node19.SetAttributeValue("class","class1");
            Console.WriteLine(node19.OuterHtml);    //輸出 <p class="class1">新建一行</p>

            Console.WriteLine(HtmlNode.IsOverlappedClosingElement("<a>我愛你</a>"));   //輸出 False
            Console.WriteLine(HtmlNode.IsCDataElement("<a>我愛你</a>"));   //輸出 False
            Console.WriteLine(HtmlNode.IsClosedElement("<a>我愛你</a>"));   //輸出 False
            Console.WriteLine(HtmlNode.IsEmptyElement("<a>我愛你</a>"));   //輸出 False
            Console.WriteLine(newnode4.OuterHtml);


            HtmlNode node20 = HtmlNode.CreateNode("<p>新的第二行</p>");
            newnode4.AppendChild(node20);
            HtmlNodeCollection hnc = newnode4.SelectNodes("//p");   //根據XPath一次過獲取多個Node
            Console.WriteLine(hnc.Count);   //輸出29

            string str1 = node20.WriteContentTo();
            Console.WriteLine(str1);    //輸出 新的第二行  將節點內容寫入字符串

            //public void WriteContentTo(TextWriter outText);
            //public string WriteTo();
            //public void WriteTo(TextWriter outText);
            //public void WriteTo(XmlWriter writer);
            Console.ReadKey();
        }

 

出處：https://www.cnblogs.com/kissdodog/archive/2013/02/28/2936950.html 

 

---

 

HtmlNodeType枚舉

 

HtmlNodeType是一個枚舉，用於說明一個節點的類型。

源代碼如下所示：

    public enum HtmlNodeType
    {
        Document = 0,
        Element = 1,
        Comment = 2,
        Text = 3,
    }

1、Document　　是文檔

2、Element　　   是元素節點

3、Conment　　 是註釋節點

4、Text　　　　  是文本節點