दिलचस्प पोस्ट
जावा में एएससीआईआई से ईबीसीडीआईसी से स्ट्रिंग को परिवर्तित करें? रूबी के पास निजी और सुरक्षित तरीके क्यों हैं? मैं कैसे पता लगा सकता है कि किस DOM तत्व का ध्यान केंद्रित है? ऑफ़लाइन स्थापना के लिए ईक्लिप्स प्लग-इन अपडेट साइट डाउनलोड करना उन्हें बंद करने के बाद stdout और stdin फ़ाइल डिस्क्रिप्टर पुन: खोलना उसी क्लिकदृश्य में किसी अन्य क्लिक करने योग्य स्प्रैन्स को प्रभावित किए बिना दबाए जाने के बाद एकल क्लिक करने योग्यस्पैन के टेक्स्ट का रंग बदलें कनेक्ट करें ईकाईनेटेड – नोड जेएस, एसक्यूएल कोण 2 में प्रपत्र परिवर्तनों के लिए कैसे देखना है? तारों के लिए जावा आउटपुट स्वरूपण कैसे एक वैश्विक चर बनाने के लिए? कैसे एक छवि पर एक रेखा खींचने के लिए? चौड़ाई फिट करने के लिए सीएसएस की पृष्ठभूमि की छवि, ऊँचाई अनुपात में स्वतः पैमाने पर होना चाहिए एक दृश्यपेज के अंदर टुकड़े को बदलें आईफ़ोन: दैनिक स्थानीय सूचनाएं तिथि के अनुसार डीजेंगो में रिकॉर्ड की गणना करें

सी # में html को पार्स करने का सबसे अच्छा तरीका क्या है?

मैं एक HTML / HTML फ़ाइल को पार्स करने के लिए एक लाइब्रेरी / विधि की तलाश कर रहा हूं, जिसमें जेनेरिक एक्सएमएल पार्सिंग पुस्तकालयों की तुलना में अधिक एचटीएमएल विशिष्ट सुविधाएं हैं।

Solutions Collecting From Web of "सी # में html को पार्स करने का सबसे अच्छा तरीका क्या है?"

HTML एगिलिटी पैक

यह एक चुस्त एचटीएमएल पार्सर है जो डॉम पढ़ता है / लिखता है और सादे एक्सपीएटीएच या एक्सएसएलटी (आप वास्तव में एक्सपीएटीएच को समझने के लिए नहीं है और न ही एक्सएसएलटी को इसका इस्तेमाल करने के लिए नहीं है, चिंता न करें …) का समर्थन करता है। यह एक .NET कोड लाइब्रेरी है जो आपको "वेब से बाहर" HTML फ़ाइलों को पार्स करने की अनुमति देती है। पार्सर "असली दुनिया" के साथ बहुत सहिष्णु है एचटीएमएल विकृत ऑब्जेक्ट मॉडल सिस्टम.एक्सएमएल के प्रस्ताव के समान है, लेकिन HTML दस्तावेज़ों (या स्ट्रीम) के लिए।

आप एचटीएमएल को एक्सएचटीएमएल में कनवर्ट करने के लिए टीडीनेट नेट का इस्तेमाल कर सकते हैं, और तब एक्सएमएल पार्सर का इस्तेमाल कर सकते हैं।

एक अन्य विकल्प, बिल्टिन इंजन mshtml का उपयोग करना होगा:

using mshtml; ... object[] oPageText = { html }; HTMLDocument doc = new HTMLDocumentClass(); IHTMLDocument2 doc2 = (IHTMLDocument2)doc; doc2.write(oPageText); 

यह आपको जावास्क्रिप्ट-जैसी कार्यों का उपयोग करने की अनुमति देता है जैसे getElementById ()

मुझे फ़िज़लर नामक एक परियोजना मिली जो HTML तत्वों का चयन करने के लिए एक jQuery / Sizzler दृष्टिकोण लेती है। यह एचटीएमएल एगिलिटी पैक पर आधारित है। यह वर्तमान में बीटा में है और केवल सीएसएस चयनकर्ताओं के एक सबसेट का समर्थन करता है, लेकिन सीएसएस चयनकर्ताओं का उपयोग करने के लिए गंदा XPath पर यह बहुत अच्छा और शांत है।

http://code.google.com/p/fizzler/

आप तीसरे पक्ष के उत्पादों और mshtml (यानी इंटरॉप) पर नट्स के बिना बहुत कुछ कर सकते हैं। System.Windows.Forms.WebBrowser का उपयोग करें। वहां से, आप HtmlDocument पर "GetElementById" या HtmlElements पर "GetElementsByTagName" जैसी चीज़ें कर सकते हैं। यदि आप वास्तव में ब्राउज़र (उदाहरण के लिए अनुकरण बटन क्लिक) के साथ पूर्णांक बनाना चाहते हैं, तो आप इसे करने के लिए थोड़ा प्रतिबिंब (इंटरॉप की तुलना में कम बुरा मान सकते हैं) का उपयोग कर सकते हैं:

 var wb = new WebBrowser() 

… नेविगेट करने के लिए ब्राउज़र को बताएं (इस प्रश्न के लिए स्पर्शरेखा)। तब Document_Completed ईवेंट पर आप इस तरह क्लिक अनुकरण कर सकते हैं।

 var doc = wb.Browser.Document var elem = doc.GetElementById(elementId); object obj = elem.DomElement; System.Reflection.MethodInfo mi = obj.GetType().GetMethod("click"); mi.Invoke(obj, new object[0]); 

आप फ़ॉर्म, आदि सबमिट करने के लिए समान प्रतिबिंब सामान कर सकते हैं।

का आनंद लें।

मैंने कुछ कोड लिखा है जो "LINQ to HTML" कार्यक्षमता प्रदान करता है मैंने सोचा कि मैं इसे यहां साझा करेगा यह मैजैक्टिक 12 पर आधारित है। यह मैजैक्टिक -12 परिणाम लेता है और LINQ XML तत्वों का उत्पादन करता है। उस बिंदु पर आप HTML के विरुद्ध अपने सभी LINQ को XML उपकरण का उपयोग कर सकते हैं। उदहारण के लिए:

  IEnumerable<XNode> auctionNodes = Majestic12ToXml.Majestic12ToXml.ConvertNodesToXml(byteArrayOfAuctionHtml); foreach (XElement anchorTag in auctionNodes.OfType<XElement>().DescendantsAndSelf("a")) { if (anchorTag.Attribute("href") == null) continue; Console.WriteLine(anchorTag.Attribute("href").Value); } 

मैं मैजैक्टिक -12 का उपयोग करना चाहता हूं क्योंकि मुझे पता है कि जंगली में पाए गए एचटीएमएल के संबंध में बहुत सारी अंतर्निहित ज्ञान हैं जो मैंने पाया है कि मैग्जेस्टिक -12 के नतीजों को मानचित्रित करने के लिए कुछ है जो LINQ को स्वीकार करेगा क्योंकि एक्सएमएल को अतिरिक्त काम की आवश्यकता है मैं जो कोड शामिल कर रहा हूं, वह बहुत सारी सफाई करता है, लेकिन जैसा कि आप इसका इस्तेमाल करते हैं, आपको ऐसे पृष्ठ मिलेंगे जो खारिज किए गए हैं। आपको यह पता करने के लिए कोड ठीक करना होगा जब कोई अपवाद फेंका जाता है, तो अपवाद को चेक करें। डेटा ["स्रोत"] क्योंकि यह संभवतः एचटीएमएल टैग पर सेट है जो अपवाद का कारण बना था। एचटीएमएल को एक अच्छी तरह से संभालना कभी-कभी तुच्छ नहीं होता …

तो अब ये उम्मीदें वास्तविक रूप से कम हैं, यहां कोड है 🙂

 using System; using System.Collections.Generic; using System.Linq; using System.Text; using Majestic12; using System.IO; using System.Xml.Linq; using System.Diagnostics; using System.Text.RegularExpressions; namespace Majestic12ToXml { public class Majestic12ToXml { static public IEnumerable<XNode> ConvertNodesToXml(byte[] htmlAsBytes) { HTMLparser parser = OpenParser(); parser.Init(htmlAsBytes); XElement currentNode = new XElement("document"); HTMLchunk m12chunk = null; int xmlnsAttributeIndex = 0; string originalHtml = ""; while ((m12chunk = parser.ParseNext()) != null) { try { Debug.Assert(!m12chunk.bHashMode); // popular default for Majestic-12 setting XNode newNode = null; XElement newNodesParent = null; switch (m12chunk.oType) { case HTMLchunkType.OpenTag: // Tags are added as a child to the current tag, // except when the new tag implies the closure of // some number of ancestor tags. newNode = ParseTagNode(m12chunk, originalHtml, ref xmlnsAttributeIndex); if (newNode != null) { currentNode = FindParentOfNewNode(m12chunk, originalHtml, currentNode); newNodesParent = currentNode; newNodesParent.Add(newNode); currentNode = newNode as XElement; } break; case HTMLchunkType.CloseTag: if (m12chunk.bEndClosure) { newNode = ParseTagNode(m12chunk, originalHtml, ref xmlnsAttributeIndex); if (newNode != null) { currentNode = FindParentOfNewNode(m12chunk, originalHtml, currentNode); newNodesParent = currentNode; newNodesParent.Add(newNode); } } else { XElement nodeToClose = currentNode; string m12chunkCleanedTag = CleanupTagName(m12chunk.sTag, originalHtml); while (nodeToClose != null && nodeToClose.Name.LocalName != m12chunkCleanedTag) nodeToClose = nodeToClose.Parent; if (nodeToClose != null) currentNode = nodeToClose.Parent; Debug.Assert(currentNode != null); } break; case HTMLchunkType.Script: newNode = new XElement("script", "REMOVED"); newNodesParent = currentNode; newNodesParent.Add(newNode); break; case HTMLchunkType.Comment: newNodesParent = currentNode; if (m12chunk.sTag == "!--") newNode = new XComment(m12chunk.oHTML); else if (m12chunk.sTag == "![CDATA[") newNode = new XCData(m12chunk.oHTML); else throw new Exception("Unrecognized comment sTag"); newNodesParent.Add(newNode); break; case HTMLchunkType.Text: currentNode.Add(m12chunk.oHTML); break; default: break; } } catch (Exception e) { var wrappedE = new Exception("Error using Majestic12.HTMLChunk, reason: " + e.Message, e); // the original html is copied for tracing/debugging purposes originalHtml = new string(htmlAsBytes.Skip(m12chunk.iChunkOffset) .Take(m12chunk.iChunkLength) .Select(B => (char)B).ToArray()); wrappedE.Data.Add("source", originalHtml); throw wrappedE; } } while (currentNode.Parent != null) currentNode = currentNode.Parent; return currentNode.Nodes(); } static XElement FindParentOfNewNode(Majestic12.HTMLchunk m12chunk, string originalHtml, XElement nextPotentialParent) { string m12chunkCleanedTag = CleanupTagName(m12chunk.sTag, originalHtml); XElement discoveredParent = null; // Get a list of all ancestors List<XElement> ancestors = new List<XElement>(); XElement ancestor = nextPotentialParent; while (ancestor != null) { ancestors.Add(ancestor); ancestor = ancestor.Parent; } // Check if the new tag implies a previous tag was closed. if ("form" == m12chunkCleanedTag) { discoveredParent = ancestors .Where(XE => m12chunkCleanedTag == XE.Name) .Take(1) .Select(XE => XE.Parent) .FirstOrDefault(); } else if ("td" == m12chunkCleanedTag) { discoveredParent = ancestors .TakeWhile(XE => "tr" != XE.Name) .Where(XE => m12chunkCleanedTag == XE.Name) .Take(1) .Select(XE => XE.Parent) .FirstOrDefault(); } else if ("tr" == m12chunkCleanedTag) { discoveredParent = ancestors .TakeWhile(XE => !("table" == XE.Name || "thead" == XE.Name || "tbody" == XE.Name || "tfoot" == XE.Name)) .Where(XE => m12chunkCleanedTag == XE.Name) .Take(1) .Select(XE => XE.Parent) .FirstOrDefault(); } else if ("thead" == m12chunkCleanedTag || "tbody" == m12chunkCleanedTag || "tfoot" == m12chunkCleanedTag) { discoveredParent = ancestors .TakeWhile(XE => "table" != XE.Name) .Where(XE => m12chunkCleanedTag == XE.Name) .Take(1) .Select(XE => XE.Parent) .FirstOrDefault(); } return discoveredParent ?? nextPotentialParent; } static string CleanupTagName(string originalName, string originalHtml) { string tagName = originalName; tagName = tagName.TrimStart(new char[] { '?' }); // for nodes <?xml > if (tagName.Contains(':')) tagName = tagName.Substring(tagName.LastIndexOf(':') + 1); return tagName; } static readonly Regex _startsAsNumeric = new Regex(@"^[0-9]", RegexOptions.Compiled); static bool TryCleanupAttributeName(string originalName, ref int xmlnsIndex, out string result) { result = null; string attributeName = originalName; if (string.IsNullOrEmpty(originalName)) return false; if (_startsAsNumeric.IsMatch(originalName)) return false; // // transform xmlns attributes so they don't actually create any XML namespaces // if (attributeName.ToLower().Equals("xmlns")) { attributeName = "xmlns_" + xmlnsIndex.ToString(); ; xmlnsIndex++; } else { if (attributeName.ToLower().StartsWith("xmlns:")) { attributeName = "xmlns_" + attributeName.Substring("xmlns:".Length); } // // trim trailing \" // attributeName = attributeName.TrimEnd(new char[] { '\"' }); attributeName = attributeName.Replace(":", "_"); } result = attributeName; return true; } static Regex _weirdTag = new Regex(@"^<!\[.*\]>$"); // matches "<![if !supportEmptyParas]>" static Regex _aspnetPrecompiled = new Regex(@"^<%.*%>$"); // matches "<%@ ... %>" static Regex _shortHtmlComment = new Regex(@"^<!-.*->$"); // matches "<!-Extra_Images->" static XElement ParseTagNode(Majestic12.HTMLchunk m12chunk, string originalHtml, ref int xmlnsIndex) { if (string.IsNullOrEmpty(m12chunk.sTag)) { if (m12chunk.sParams.Length > 0 && m12chunk.sParams[0].ToLower().Equals("doctype")) return new XElement("doctype"); if (_weirdTag.IsMatch(originalHtml)) return new XElement("REMOVED_weirdBlockParenthesisTag"); if (_aspnetPrecompiled.IsMatch(originalHtml)) return new XElement("REMOVED_ASPNET_PrecompiledDirective"); if (_shortHtmlComment.IsMatch(originalHtml)) return new XElement("REMOVED_ShortHtmlComment"); // Nodes like "<br <br>" will end up with a m12chunk.sTag==""... We discard these nodes. return null; } string tagName = CleanupTagName(m12chunk.sTag, originalHtml); XElement result = new XElement(tagName); List<XAttribute> attributes = new List<XAttribute>(); for (int i = 0; i < m12chunk.iParams; i++) { if (m12chunk.sParams[i] == "<!--") { // an HTML comment was embedded within a tag. This comment and its contents // will be interpreted as attributes by Majestic-12... skip this attributes for (; i < m12chunk.iParams; i++) { if (m12chunk.sTag == "--" || m12chunk.sTag == "-->") break; } continue; } if (m12chunk.sParams[i] == "?" && string.IsNullOrEmpty(m12chunk.sValues[i])) continue; string attributeName = m12chunk.sParams[i]; if (!TryCleanupAttributeName(attributeName, ref xmlnsIndex, out attributeName)) continue; attributes.Add(new XAttribute(attributeName, m12chunk.sValues[i])); } // If attributes are duplicated with different values, we complain. // If attributes are duplicated with the same value, we remove all but 1. var duplicatedAttributes = attributes.GroupBy(A => A.Name).Where(G => G.Count() > 1); foreach (var duplicatedAttribute in duplicatedAttributes) { if (duplicatedAttribute.GroupBy(DA => DA.Value).Count() > 1) throw new Exception("Attribute value was given different values"); attributes.RemoveAll(A => A.Name == duplicatedAttribute.Key); attributes.Add(duplicatedAttribute.First()); } result.Add(attributes); return result; } static HTMLparser OpenParser() { HTMLparser oP = new HTMLparser(); // The code+comments in this function are from the Majestic-12 sample documentation. // ... // This is optional, but if you want high performance then you may // want to set chunk hash mode to FALSE. This would result in tag params // being added to string arrays in HTMLchunk object called sParams and sValues, with number // of actual params being in iParams. See code below for details. // // When TRUE (and its default) tag params will be added to hashtable HTMLchunk (object).oParams oP.SetChunkHashMode(false); // if you set this to true then original parsed HTML for given chunk will be kept - // this will reduce performance somewhat, but may be desireable in some cases where // reconstruction of HTML may be necessary oP.bKeepRawHTML = false; // if set to true (it is false by default), then entities will be decoded: this is essential // if you want to get strings that contain final representation of the data in HTML, however // you should be aware that if you want to use such strings into output HTML string then you will // need to do Entity encoding or same string may fail later oP.bDecodeEntities = true; // we have option to keep most entities as is - only replace stuff like &nbsp; // this is called Mini Entities mode - it is handy when HTML will need // to be re-created after it was parsed, though in this case really // entities should not be parsed at all oP.bDecodeMiniEntities = true; if (!oP.bDecodeEntities && oP.bDecodeMiniEntities) oP.InitMiniEntities(); // if set to true, then in case of Comments and SCRIPT tags the data set to oHTML will be // extracted BETWEEN those tags, rather than include complete RAW HTML that includes tags too // this only works if auto extraction is enabled oP.bAutoExtractBetweenTagsOnly = true; // if true then comments will be extracted automatically oP.bAutoKeepComments = true; // if true then scripts will be extracted automatically: oP.bAutoKeepScripts = true; // if this option is true then whitespace before start of tag will be compressed to single // space character in string: " ", if false then full whitespace before tag will be returned (slower) // you may only want to set it to false if you want exact whitespace between tags, otherwise it is just // a waste of CPU cycles oP.bCompressWhiteSpaceBeforeTag = true; // if true (default) then tags with attributes marked as CLOSED (/ at the end) will be automatically // forced to be considered as open tags - this is no good for XML parsing, but I keep it for backwards // compatibility for my stuff as it makes it easier to avoid checking for same tag which is both closed // or open oP.bAutoMarkClosedTagsWithParamsAsOpen = false; return oP; } } } 

एचएफ़टीएम एगिलिटी पैक का उल्लेख पहले किया गया है – अगर आप गति के लिए जा रहे हैं, तो आप मेजेस्टिक -12 एचटीएमएल पार्सर की भी जांच कर सकते हैं। इसकी संभाल बल्कि बदली हुई है, लेकिन यह वास्तव में तेजी से पार्सिंग अनुभव बचाता है।

मुझे लगता है कि @ HTMLDocument का उपयोग HTMLDocument का सबसे अच्छा तरीका है हालांकि, मेरे पास इस सरल पुस्तकालय का उपयोग करने के लिए शुभकामनाएं भी हैं:

SgmlReader

कोई तृतीय पक्ष लिब, WebBrowser वर्ग समाधान जो कंसोल पर चल सकता है, और asp.net

 using System; using System.Collections.Generic; using System.Text; using System.Windows.Forms; using System.Threading; class ParseHTML { public ParseHTML() { } private string ReturnString; public string doParsing(string html) { Thread t = new Thread(TParseMain); t.ApartmentState = ApartmentState.STA; t.Start((object)html); t.Join(); return ReturnString; } private void TParseMain(object html) { WebBrowser wbc = new WebBrowser(); wbc.DocumentText = "feces of a dummy"; //;magic words HtmlDocument doc = wbc.Document.OpenNew(true); doc.Write((string)html); this.ReturnString = doc.Body.InnerHtml + " do here something"; return; } } 

उपयोग:

 string myhtml = "<HTML><BODY>This is a new HTML document.</BODY></HTML>"; Console.WriteLine("before:" + myhtml); myhtml = (new ParseHTML()).doParsing(myhtml); Console.WriteLine("after:" + myhtml); 

HTML को पार्स करने में परेशानी यह है कि यह सटीक विज्ञान नहीं है अगर यह एक्सएचटीएलएल था जो आप पार्सिंग कर रहे थे, तो चीजें बहुत आसान होगी (जैसा कि आप उल्लेख करते हैं कि आप सामान्य एक्सएमएल पार्सर का उपयोग कर सकते हैं)। क्योंकि एचटीएमएल जरूरी नहीं है कि आप इसे एक्सप्लोर करने की कोशिश कर रहे हैं। साइट-दर-साइट के आधार पर यह लगभग पूरी तरह से करना आवश्यक है

मैंने अतीत में जेटाहैमटिडी का इस्तेमाल किया है ताकि यादृच्छिक वेबसाइटों को लोड किया जा सके और फिर एक्सपाथ (जैसे / html / body // p [@ class = 'textblock']) के साथ सामग्री के विभिन्न हिस्सों के विरुद्ध मारा। यह अच्छी तरह से काम किया लेकिन कुछ असाधारण साइटें थीं जिनके साथ समस्याएं थीं, इसलिए मुझे नहीं पता कि यह बिल्कुल सही समाधान है या नहीं।

आप एक एचटीएमएल डीटीडी, और सामान्य एक्सएमएल पार्सिंग लाइब्रेरी का उपयोग कर सकते हैं।

WATN का उपयोग करें यदि आपको पेज पर जेएस के प्रभाव को देखने की आवश्यकता है [और आप ब्राउज़र शुरू करने के लिए तैयार हैं]

अपनी आवश्यकताओं के आधार पर आप अधिक सुविधा-संपन्न पुस्तकालयों के लिए जा सकते हैं। मैंने सबसे अधिक / सभी सुझावों का सुझाव दिया, लेकिन जो सिर और कंधों के बाहर खड़ा था वह HTML एगिलिटी पैक था। यह बहुत क्षमा और लचीली पार्सर है

इस स्क्रिप्ट की कोशिश करो

http://www.biterscripting.com/SS_URLs.html

जब मैं इसे इस यूआरएल के साथ प्रयोग करता हूँ,

 script SS_URLs.txt URL("http://stackoverflow.com/questions/56107/what-is-the-best-way-to-parse-html-in-c") 

यह मुझे इस धागे के पृष्ठ पर सभी लिंक दिखाता है।

 http://sstatic.net/so/all.css http://sstatic.net/so/favicon.ico http://sstatic.net/so/apple-touch-icon.png . . . 

आप उस स्क्रिप्ट को छवियों, वेरिएबल्स, जो कुछ भी देख सकते हैं, को संशोधित कर सकते हैं।

मैंने सी # में एचटीएमएल टैग पार्स करने के लिए कुछ कक्षाएं लिखीं। वे अच्छे और सरल हैं यदि वे आपकी विशेष आवश्यकताओं को पूरा करते हैं।

आप उनके बारे में एक लेख पढ़ सकते हैं और http://www.blackbeltcoder.com/Articles/strings/parsing-html-tags-in-c पर स्रोत कोड डाउनलोड कर सकते हैं।

http://www.blackbeltcoder.com/Articles/strings/a-text-parsing-helper-class पर जेनेरिक पर्सिंग सहायक वर्ग के बारे में एक लेख भी है।