C# HtmlTag.AddChildren方法代码示例

        /// <summary>
        /// This function replaces strings in the plain text parts of the html. So tag names will not be replaced, just the plain content of the tags.
        /// </summary>
        /// <param name="HtmlInput">The Html-String you want to replace strings in.</param>
        /// <param name="TextReplacementMap">Dictionary in which the strings and the replacements of them are defined. 
        /// (Form: Key-OldString, Value-NewString) If you want to remove a string, just replace it with a clear string.</param>
        /// <returns></returns>
        public string ReplaceStringsFromPlainTextElements(string HtmlInput, Dictionary<string, string> TextReplacementMap)
        {
            HtmlTag root = new HtmlTag(null, false, "root");
            HtmlConstruct children = Analyze(HtmlInput, root);
            root.AddChildren(children.elements);
            IHtmlTagIterator iterator = root.getIterator();

            while (iterator.hasNext())
            {
                HtmlElement element = iterator.next();
                if (element.GetType() == typeof(HtmlPlainText))
                {
                    HtmlPlainText PlainText = ((HtmlPlainText)element);
                    foreach (KeyValuePair<string, string> MapItem in TextReplacementMap)
                    {
                        PlainText.content = PlainText.content.Replace(MapItem.Key, MapItem.Value);
                    }
                }
            }

            return new HtmlConstruct(root.children).ToString();
        }

        /// <summary>
        /// This function analyzes the Input-Html-Text and converts it to an analogous object structure.
        /// </summary>
        /// <param name="HtmlInput">The Html-String you want to analyze.</param>
        /// <returns></returns>
        public HtmlConstruct Analyze(string HtmlInput, HtmlTag parent)
        {
            List<HtmlElement> output = new List<HtmlElement>();
            string TagName = "";
            string TagAttributes = "";
            int StartPosition = 0;
            int EndPosition = 0;

            while (FindFirstOpeningTag(HtmlInput, out TagName, out TagAttributes, out StartPosition, out EndPosition))
            {
                string davor = HtmlInput.Substring(0, StartPosition);
                davor = RemoveAllHtmlTags(davor);
                if (davor != "") output.Add(new HtmlPlainText(parent, davor));

                int StartClosing = 0;
                int EndClosing = 0;
                if (FindClosingTag(HtmlInput, TagName, EndPosition, out StartClosing, out EndClosing))
                {
                    HtmlTag t = new HtmlTag(parent, false, TagName, AnalyzeTagAttributes(TagAttributes));
                    HtmlConstruct c = Analyze(HtmlInput.Substring(EndPosition, StartClosing - EndPosition), t);
                    t.AddChildren(c.elements);
                    output.Add(t);
                    HtmlInput = HtmlInput.Substring(EndClosing);
                }
                else
                {
                    output.Add(new HtmlTag(parent, true, TagName, AnalyzeTagAttributes(TagAttributes)));
                    HtmlInput = HtmlInput.Substring(EndPosition);
                }
            }

            if (HtmlInput != "") output.Add(new HtmlPlainText(parent, HtmlInput));

            return new HtmlConstruct(output);
        }

 /// <summary>
 /// This function replaces the Html-Tag-Names from the input, while it conserves the structure of the html and possible Html-Attributes.
 /// </summary>
 /// <param name="HtmlInput">The Html-String you want to replace tags in.</param>
 /// <param name="TagReplacementMap">Dictionary in which the replacement rules are defined. (Form: Key-OldTagName, Value-NewTagName)</param>
 /// <param name="ReplacementType">Whether or not unmatched Tags (and their content!) should remain in the string.</param>
 /// <returns></returns>
 public string ApplyTagReplacementMap(string HtmlInput, Dictionary<string, string> TagReplacementMap, TagReplacementTypes ReplacementType)
 {
     HtmlTag root = new HtmlTag(null, false, "root");
     HtmlConstruct ObjectConstruct = Analyze(HtmlInput, root);
     root.AddChildren(ObjectConstruct.elements);
     IHtmlTagIterator i = ObjectConstruct.getIterator();
     while (i.hasNext())
     {
         HtmlElement ele = i.next();
         if (ele.GetType() == typeof(HtmlPlainText)) // Current element is Plain Text
         {
             // ((HtmlPlainText)ele)
             // ignore
         }
         else if (ele.GetType() == typeof(HtmlTag)) // Current element is tag
         {
             // ((HtmlTag)ele)
             if (TagReplacementMap.Keys.Contains(((HtmlTag)ele).tagName)) // tag found in ReplacementMap
             {
                 // Replace
                 HtmlTag replacement = new HtmlTag(((HtmlTag)ele).getParent(), ((HtmlTag)ele).isSingleTag, TagReplacementMap[((HtmlTag)ele).tagName], ((HtmlTag)ele).children, ((HtmlTag)ele).tagAttributes);
                 int index = ((HtmlTag)ele).getParent().children.IndexOf(ele);
                 ((HtmlTag)ele).getParent().children[index] = replacement;
             }
             else // tag not found in ReplacementMap
             {
                 switch (ReplacementType)
                 {
                     case TagReplacementTypes.RemoveNotMatchedTags:
                         ((HtmlTag)ele).getParent().children.Remove(ele);
                         break;
                     case TagReplacementTypes.IgnoreNotMatchedTags:
                         // ignore
                         break;
                     case TagReplacementTypes.ConvertNotMatchedTagsToPlainText:
                         string plaintext = "";
                         IHtmlTagIterator it = ((HtmlTag)ele).getIterator();
                         while (it.hasNext())
                         {
                             HtmlElement e = it.next();
                             if (e.GetType() == typeof(HtmlPlainText)) plaintext += ((HtmlPlainText)e).content;
                         }
                         HtmlPlainText replacement = new HtmlPlainText(((HtmlTag)ele).getParent(), plaintext);
                         int index = ((HtmlTag)ele).getParent().children.IndexOf(ele);
                         ((HtmlTag)ele).getParent().children[index] = replacement;
                         break;
                     default:
                         throw new NotImplementedException("TagReplacementType not implemented!"); //break;
                 }
             }
         }
         else throw new NotImplementedException("HtmlElement Type not implemented!");
     }
     return new HtmlConstruct(root.children).ToString();
 }