【问题标题】:Convert (render) HTML to Text with correct line-breaks使用正确的换行符将 HTML 转换(呈现)为文本
【发布时间】:2015-07-11 18:50:06
【问题描述】:

我需要将 HTML 字符串转换为纯文本(最好使用 HTML Agility 包)。使用适当的空格,尤其是适当的换行符。

我所说的“适当的换行符”是指这段代码:

<div>
    <div>
        <div>
            line1
        </div>
    </div>
</div>
<div>line2</div>

应该转换为

line1
line2

即只有一个换行符。

我见过的大多数解决方案都只是将所有&lt;div&gt; &lt;br&gt; &lt;p&gt; 标签转换为\n,这显然是s*cks。

对于 C# 的 html 到纯文本渲染 logic 有什么建议吗?不是完整的代码,至少是常见的逻辑答案,例如“用换行符替换所有关闭的 DIV,但前提是下一个兄弟也不是 DIV”会真正有帮助。

我尝试过的事情:简单地获取.InnerText 属性(显然是错误的)、正则表达式(缓慢、痛苦、大量黑客攻击,而且正则表达式比 HtmlAgilityPack 慢 12 倍 - 我测量了它),这个 solution 和类似的(返回更多的换行符然后需要)

【问题讨论】:

  • 应该可以检查 HtmlNode 类型(是否阻塞)并做一些智能布局......如果你想走 HtmlAgilityPack 路线。除此之外,这个 BCL 类可能工作:msdn.microsoft.com/en-us/library/windows/apps/…
  • @jessehouwing 是的,我就是这么想的。 PS。我可能应该提到它是一个 ASP.NET MVC 应用程序 (.NET 4),不想使用“地铁应用程序”类。
  • 您的问题与 stackoverflow 的措辞无关:“对于 C# 的轻量级 html 到纯文本渲染引擎有什么建议吗?” - SO 不适用于软件推荐。反对它的票数很接近,如果不是公开赏金的话,还会有更多。你应该考虑改写你的问题。
  • @antiduh 谢谢,这样做
  • 在我看来,Html 本身根本无法正确转换为纯文本。至少,不是不考虑 css。

标签: c# html-agility-pack


【解决方案1】:

我对 html-agility-pack 了解不多,但这里有一个 c# 替代方案。

    public string GetPlainText()
    {
        WebRequest request = WebRequest.Create("URL for page you want to 'stringify'");
        WebResponse response = request.GetResponse();
        Stream data = response.GetResponseStream();
        string html = String.Empty;
        using (StreamReader sr = new StreamReader(data))
        {
            html = sr.ReadToEnd();
        }

        html = Regex.Replace(html, "<.*?>", "\n");

        html = Regex.Replace(html, @"\\r|\\n|\n|\r", @"$");
        html = Regex.Replace(html, @"\$ +", @"$");
        html = Regex.Replace(html, @"(\$)+", Environment.NewLine);

        return html;
    }

如果您打算在 html 页面中显示此内容,请将 Environment.NewLine 替换为 &lt;br/&gt;。

【讨论】:

  • 它将用换行符替换所有标签(甚至是内联标签,如&lt;b&gt;)。此外,如果它们是有意的(如&lt;br&gt;&lt;br&gt;&lt;br&gt;),则可以使用多个换行符
  • @ErikPhilips 哦,加油!您不是在认真地说某人只想做一个简单的 Replace("
    ", @"\r\n"),必须通过 HTML AP 来做?
【解决方案2】:

下面的类提供了innerText 的替代实现。它不会为后续的 div 发出多个换行符,因为它只考虑区分不同文本内容的标签。评估每个文本节点的父节点以确定是否要插入换行符或空格。因此,任何不包含直接文本的标签都会被自动忽略。

您提出的案例提供了与您期望的结果相同的结果。此外:

<div>ABC<br>DEF<span>GHI</span></div>

给予

ABC
DEF GHI

同时

<div>ABC<br>DEF<div>GHI</div></div>

给予

ABC
DEF
GHI

因为div 是一个块标签。 script 和 style 元素被完全忽略。 HttpUtility.HtmlDecode 实用方法(在System.Web 中)用于解码HTML 转义文本,如&amp;amp;。多次出现的空格 (\s+) 被单个空格替换。 br 标签如果重复不会导致多个换行符。

static class HtmlTextProvider
{
    private static readonly HashSet<string> InlineElementNames = new HashSet<string>
    {
        //from https://developer.mozilla.org/en-US/docs/Web/HTML/Inline_elemente
        "b", "big", "i", "small", "tt", "abbr", "acronym", 
        "cite", "code", "dfn", "em", "kbd", "strong", "samp", 
        "var", "a", "bdo", "br", "img", "map", "object", "q", 
        "script", "span", "sub", "sup", "button", "input", "label", 
        "select", "textarea"
    }; 

    private static readonly Regex WhitespaceNormalizer = new Regex(@"(\s+)", RegexOptions.Compiled);

    private static readonly HashSet<string> ExcludedElementNames = new HashSet<string>
    {
        "script", "style"
    }; 

    public static string GetFormattedInnerText(this HtmlDocument document)
    {
        var textBuilder = new StringBuilder();
        var root = document.DocumentNode;
        foreach (var node in root.Descendants())
        {
            if (node is HtmlTextNode && !ExcludedElementNames.Contains(node.ParentNode.Name))
            {
                var text = HttpUtility.HtmlDecode(node.InnerText);
                text = WhitespaceNormalizer.Replace(text, " ").Trim();
                if(string.IsNullOrWhiteSpace(text)) continue;
                var whitespace = InlineElementNames.Contains(node.ParentNode.Name) ? " " : Environment.NewLine;
                //only 
                if (EndsWith(textBuilder, " ") && whitespace == Environment.NewLine)
                {
                    textBuilder.Remove(textBuilder.Length - 1, 1);
                    textBuilder.AppendLine();
                }
                textBuilder.Append(text);
                textBuilder.Append(whitespace);
                if (!char.IsWhiteSpace(textBuilder[textBuilder.Length - 1]))
                {
                    if (InlineElementNames.Contains(node.ParentNode.Name))
                    {
                        textBuilder.Append(' ');
                    }
                    else
                    {
                        textBuilder.AppendLine();
                    }
                }
            }
            else if (node.Name == "br" && EndsWith(textBuilder, Environment.NewLine))
            {
                textBuilder.AppendLine();
            }
        }
        return textBuilder.ToString().TrimEnd(Environment.NewLine.ToCharArray());
    }

    private static bool EndsWith(StringBuilder builder, string value)
    {
        return builder.Length > value.Length && builder.ToString(builder.Length - value.Length, value.Length) == value;
    }
}

【讨论】:

  • &lt;div&gt;line1&lt;/div&gt;line2 失败
  • @jitbit 这取决于您提供的示例的父级。它在&lt;span&gt;&lt;div&gt;line1&lt;/div&gt;line2&lt;/span&gt; 上失败。看起来应该在前后都强制换行,类似于块元素的实际逻辑。我更改了逻辑以适应这一点。
【解决方案3】:

以下代码对我有用:

 static void Main(string[] args)
        {
              StringBuilder sb = new StringBuilder();
        string path = new WebClient().DownloadString("https://www.google.com");
        HtmlDocument htmlDoc = new HtmlDocument();
        ////htmlDoc.LoadHtml(File.ReadAllText(path));
        htmlDoc.LoadHtml(path);
        var bodySegment = htmlDoc.DocumentNode.Descendants("body").FirstOrDefault();
        if (bodySegment != null)
        {
            foreach (var item in bodySegment.ChildNodes)
            {
                if (item.NodeType == HtmlNodeType.Element && string.Compare(item.Name, "script", true) != 0)
                {
                    foreach (var a in item.Descendants())
                    {
                        if (string.Compare(a.Name, "script", true) == 0 || string.Compare(a.Name, "style", true) == 0)
                        {
                            a.InnerHtml = string.Empty;
                        }
                    }
                    sb.AppendLine(item.InnerText.Trim());
                }
            }
        }


            Console.WriteLine(sb.ToString());
            Console.Read();
        }

【讨论】:

  • 试试htmlDoc.LoadHtml(new WebClient().DownloadString("https://www.google.com")) ;)
  • 编辑了代码,但似乎google页面在每个div中都有太多的脚本,所以结果太混乱了。我尝试比较数据并感到困惑,所以尽管得到一些帮助:) ...请让我知道上面的代码有多好。
  • new WebClient().DownloadString("stackoverflow.com/"); 结果看起来更好一些并且易于比较...请验证..
  • 我有一个疑问: - 我们是否需要将每个嵌套 div 的数据放在单独的行上?
  • 这将为每个元素添加新行,而不仅仅是块元素
【解决方案4】:

下面的代码在提供的示例中可以正常工作,甚至可以处理一些奇怪的东西,比如&lt;div&gt;&lt;br&gt;&lt;/div&gt;,还有一些需要改进的地方,但基本的想法就在那里。见 cmets。

public static string FormatLineBreaks(string html)
{
    //first - remove all the existing '\n' from HTML
    //they mean nothing in HTML, but break our logic
    html = html.Replace("\r", "").Replace("\n", " ");

    //now create an Html Agile Doc object
    HtmlDocument doc = new HtmlDocument();
    doc.LoadHtml(html);

    //remove comments, head, style and script tags
    foreach (HtmlNode node in doc.DocumentNode.SafeSelectNodes("//comment() | //script | //style | //head"))
    {
        node.ParentNode.RemoveChild(node);
    }

    //now remove all "meaningless" inline elements like "span"
    foreach (HtmlNode node in doc.DocumentNode.SafeSelectNodes("//span | //label")) //add "b", "i" if required
    {
        node.ParentNode.ReplaceChild(HtmlNode.CreateNode(node.InnerHtml), node);
    }

    //block-elements - convert to line-breaks
    foreach (HtmlNode node in doc.DocumentNode.SafeSelectNodes("//p | //div")) //you could add more tags here
    {
        //we add a "\n" ONLY if the node contains some plain text as "direct" child
        //meaning - text is not nested inside children, but only one-level deep

        //use XPath to find direct "text" in element
        var txtNode = node.SelectSingleNode("text()");

        //no "direct" text - NOT ADDDING the \n !!!!
        if (txtNode == null || txtNode.InnerHtml.Trim() == "") continue;

        //"surround" the node with line breaks
        node.ParentNode.InsertBefore(doc.CreateTextNode("\r\n"), node);
        node.ParentNode.InsertAfter(doc.CreateTextNode("\r\n"), node);
    }

    //todo: might need to replace multiple "\n\n" into one here, I'm still testing...

    //now BR tags - simply replace with "\n" and forget
    foreach (HtmlNode node in doc.DocumentNode.SafeSelectNodes("//br"))
        node.ParentNode.ReplaceChild(doc.CreateTextNode("\r\n"), node);

    //finally - return the text which will have our inserted line-breaks in it
    return doc.DocumentNode.InnerText.Trim();

    //todo - you should probably add "&code;" processing, to decode all the &nbsp; and such
}    

//here's the extension method I use
private static HtmlNodeCollection SafeSelectNodes(this HtmlNode node, string selector)
{
    return (node.SelectNodes(selector) ?? new HtmlNodeCollection(node));
}

【讨论】:

  • 什么是 SafeSelectNodes?你用的是什么库
  • 当我使用问题中的示例时,这会在第一个 SelectNodes 中为我抛出一个 NullReferenceException。
  • 抱歉,忘记包含我一直使用的 HtmlAgilityPack 扩展方法(顺便在 SO 上找到)
  • @SergeShultz 我只是想知道你是否找到了一种更好的方法来处理多个“\n\n”?
  • 关于返回后的//todo,System.Web.HttpUtility自行处理,最后使用return HttpUtility.HtmlDecode(doc.DocumentNode.InnerText.Trim());即可。
【解决方案5】:

我不认为 SO 是关于交换赏金以编写完整的代码解决方案。我认为最好的答案是那些提供指导并帮助您自己解决问题的答案。本着这种精神,我想到了一个应该起作用的过程:

  1. 用单个空格替换任意长度的空白字符(这是为了表示标准的 HTML 空白处理规则)
  2. 用换行符替换 &lt;/div&gt; 的所有实例
  3. 使用单个换行符折叠任何多个换行符实例
  4. 用换行符替换 &lt;/p&gt;、&lt;br&gt; 和 &lt;br/&gt; 的实例
  5. 删除所有剩余的 html 打开/关闭标签
  6. 展开任何实体,例如&amp;trade; 根据需要
  7. 修剪输出以删除尾随和前导空格

基本上,您希望每个段落或换行选项卡都有一个换行符,但要折叠多个 div 闭包并使用一个单独的闭包 - 先做这些。

最后请注意,您实际上是在执行 HTML 布局,这取决于标签的 CSS。您看到的行为是因为 div 默认为块显示/布局模式。 CSS 会改变这一点。如果没有无头布局/渲染引擎,即可以处理 CSS 的东西,就没有简单的方法来解决这个问题。

但是对于您的简单示例,上述方法应该是合理的。

【讨论】:

  • opening &lt;div&gt; &lt;p&gt; 在某些情况下也应该替换为换行符
  • 请问-如果您了解以上所有内容以及您指出的规则,是什么阻止您自己编写代码?看起来没有太多 SO 问题了 - 如果您正在寻找一个库或有人来编写代码,我不确定这是否在此范围内?
  • 我不能! :) 我一直在努力解决这个问题太久了,似乎无法想出一个简单的逻辑/规则集来涵盖所有情况......不过,Serge Shutlz 和 Bas 已经很接近了,他们俩都给出了很好的答案.逻辑是“忽略其中没有直接(非嵌套)文本的 html 节点”。
【解决方案6】:

关注点:

  1. 不可见的标签(脚本、样式)
  2. 块级标签
  3. 内嵌标签
  4. Br 标记
  5. 可换行的空格(前导、尾随和多个空格)
  6. Hard spaces
  7. 实体

代数决策:

  plain-text = Process(Plain(html))

  Plain(node-s) => Plain(node-0), Plain(node-1), ..., Plain(node-N)
  Plain(BR) => BR
  Plain(not-visible-element(child-s)) => nil
  Plain(block-element(child-s)) => BS, Plain(child-s), BE
  Plain(inline-element(child-s)) => Plain(child-s)   
  Plain(text) => ch-0, ch-1, .., ch-N

  Process(symbol-s) => Process(start-line, symbol-s)

  Process(start-line, BR, symbol-s) => Print('\n'), Process(start-line, symbol-s)
  Process(start-line, BS, symbol-s) => Process(start-line, symbol-s)
  Process(start-line, BE, symbol-s) => Process(start-line, symbol-s)
  Process(start-line, hard-space, symbol-s) => Print(' '), Process(not-ws, symbol-s)
  Process(start-line, space, symbol-s) => Process(start-line, symbol-s)
  Process(start-line, common-symbol, symbol-s) => Print(common-symbol), 
                                                  Process(not-ws, symbol-s)

  Process(not-ws, BR|BS|BE, symbol-s) => Print('\n'), Process(start-line, symbol-s)
  Process(not-ws, hard-space, symbol-s) => Print(' '), Process(not-ws, symbol-s)
  Process(not-ws, space, symbol-s) => Process(ws, symbol-s)
  Process(not-ws, common-symbol, symbol-s) => Process(ws, symbol-s)

  Process(ws, BR|BS|BE, symbol-s) => Print('\n'), Process(start-line, symbol-s)
  Process(ws, hard-space, symbol-s) => Print(' '), Print(' '), 
                                       Process(not-ws, symbol-s)
  Process(ws, space, symbol-s) => Process(ws, symbol-s)
  Process(ws, common-symbol, symbol-s) => Print(' '), Print(common-symbol),
                                          Process(not-ws, symbol-s)

针对 HtmlAgilityPack 和 System.Xml.Linq 的 C# 决策:

  //HtmlAgilityPack part
  public static string ToPlainText(this HtmlAgilityPack.HtmlDocument doc)
  {
    var builder = new System.Text.StringBuilder();
    var state = ToPlainTextState.StartLine;

    Plain(builder, ref state, new[]{doc.DocumentNode});
    return builder.ToString();
  }
  static void Plain(StringBuilder builder, ref ToPlainTextState state, IEnumerable<HtmlAgilityPack.HtmlNode> nodes)
  {
    foreach (var node in nodes)
    {
      if (node is HtmlAgilityPack.HtmlTextNode)
      {
        var text = (HtmlAgilityPack.HtmlTextNode)node;
        Process(builder, ref state, HtmlAgilityPack.HtmlEntity.DeEntitize(text.Text).ToCharArray());
      }
      else
      {
        var tag = node.Name.ToLower();

        if (tag == "br")
        {
          builder.AppendLine();
          state = ToPlainTextState.StartLine;
        }
        else if (NonVisibleTags.Contains(tag))
        {
        }
        else if (InlineTags.Contains(tag))
        {
          Plain(builder, ref state, node.ChildNodes);
        }
        else
        {
          if (state != ToPlainTextState.StartLine)
          {
            builder.AppendLine();
            state = ToPlainTextState.StartLine;
          }
          Plain(builder, ref state, node.ChildNodes);
          if (state != ToPlainTextState.StartLine)
          {
            builder.AppendLine();
            state = ToPlainTextState.StartLine;
          }
        }

      }

    }
  }

  //System.Xml.Linq part
  public static string ToPlainText(this IEnumerable<XNode> nodes)
  {
    var builder = new System.Text.StringBuilder();
    var state = ToPlainTextState.StartLine;

    Plain(builder, ref state, nodes);
    return builder.ToString();
  }
  static void Plain(StringBuilder builder, ref ToPlainTextState state, IEnumerable<XNode> nodes)
  {
    foreach (var node in nodes)
    {
      if (node is XElement)
      {
        var element = (XElement)node;
        var tag = element.Name.LocalName.ToLower();

        if (tag == "br")
        {
          builder.AppendLine();
          state = ToPlainTextState.StartLine;
        }
        else if (NonVisibleTags.Contains(tag))
        {
        }
        else if (InlineTags.Contains(tag))
        {
          Plain(builder, ref state, element.Nodes());
        }
        else
        {
          if (state != ToPlainTextState.StartLine)
          {
            builder.AppendLine();
            state = ToPlainTextState.StartLine;
          }
          Plain(builder, ref state, element.Nodes());
          if (state != ToPlainTextState.StartLine)
          {
            builder.AppendLine();
            state = ToPlainTextState.StartLine;
          }
        }

      }
      else if (node is XText)
      {
        var text = (XText)node;
        Process(builder, ref state, text.Value.ToCharArray());
      }
    }
  }
  //common part
  public static void Process(System.Text.StringBuilder builder, ref ToPlainTextState state, params char[] chars)
  {
    foreach (var ch in chars)
    {
      if (char.IsWhiteSpace(ch))
      {
        if (IsHardSpace(ch))
        {
          if (state == ToPlainTextState.WhiteSpace)
            builder.Append(' ');
          builder.Append(' ');
          state = ToPlainTextState.NotWhiteSpace;
        }
        else
        {
          if (state == ToPlainTextState.NotWhiteSpace)
            state = ToPlainTextState.WhiteSpace;
        }
      }
      else
      {
        if (state == ToPlainTextState.WhiteSpace)
          builder.Append(' ');
        builder.Append(ch);
        state = ToPlainTextState.NotWhiteSpace;
      }
    }
  }
  static bool IsHardSpace(char ch)
  {
    return ch == 0xA0 || ch ==  0x2007 || ch == 0x202F;
  }

  private static readonly HashSet<string> InlineTags = new HashSet<string>
  {
      //from https://developer.mozilla.org/en-US/docs/Web/HTML/Inline_elemente
      "b", "big", "i", "small", "tt", "abbr", "acronym", 
      "cite", "code", "dfn", "em", "kbd", "strong", "samp", 
      "var", "a", "bdo", "br", "img", "map", "object", "q", 
      "script", "span", "sub", "sup", "button", "input", "label", 
      "select", "textarea"
  };

  private static readonly HashSet<string> NonVisibleTags = new HashSet<string>
  {
      "script", "style"
  };

  public enum ToPlainTextState
  {
    StartLine = 0,
    NotWhiteSpace,
    WhiteSpace,
  }

}

例子:

// <div>  1 </div>  2 <div> 3  </div>
1
2
3
//  <div>1  <br/><br/>&#160; <b> 2 </b> <div>   </div><div> </div>  &#160;3</div>
1

  2
 3
//  <span>1<style> text </style><i>2</i></span>3
123
//<div>
//    <div>
//        <div>
//            line1
//        </div>
//    </div>
//</div>
//<div>line2</div>
line1
line2

【讨论】:

  • 一段时间后,我发现这种方法比公认的答案更好。
【解决方案7】:

我的项目总是使用CsQuery。据说它比 HtmlAgilityPack 更快,并且更容易与 css 选择器而不是 xpath 一起使用。

var html = @"<div>
    <div>
        <div>
            line1
        </div>
    </div>
</div>
<div>line2</div>";

var lines = CQ.Create(html)
              .Text()
              .Replace("\r\n", "\n") // I like to do this before splitting on line breaks
              .Split('\n')
              .Select(s => s.Trim()) // Trim elements
              .Where(s => !s.IsNullOrWhiteSpace()) // Remove empty lines
              ;

var result = string.Join(Environment.NewLine, lines);

上述代码按预期工作,但是如果您有一个具有预期结果的更复杂示例,则可以轻松适应此代码。

例如,如果您想保留 &lt;br&gt;,您可以在 html 变量中将其替换为“---br---”之类的内容,然后在最终结果中再次对其进行拆分。

【讨论】:

  • 咳咳……它不起作用。使用&lt;div&gt;line1&lt;/div&gt;line2 进行测试。另外-为什么要删除空行?如果它们是有意的怎么办?像&lt;br&gt;&lt;br&gt; 一样,CsQuery 也比较慢。在此处查看图表:github.com/FlorianRappl/AngleSharp/wiki/Performance
【解决方案8】:

无正则表达式解决方案:

while (text.IndexOf("\n\n") > -1 || text.IndexOf("\n \n") > -1)
{
    text = text.Replace("\n\n", "\n");
    text = text.Replace("\n \n", "\n");
}

正则表达式:

text = Regex.Replace(text, @"^\s*$\n|\r", "", RegexOptions.Multiline).TrimEnd();

另外,我记得,

text = HtmlAgilityPack.HtmlEntity.DeEntitize(text);

帮个忙。

【讨论】:

    【解决方案9】:

    2021 年 3 月更新 top annswer

    更新包括 HtmlAgilityPack 更改(新方法而不是不存在的方法)和 HTML 解码 HTML 实体(即。)。

    public static string FormatLineBreaks(string html)
    {
        //first - remove all the existing '\n' from HTML
        //they mean nothing in HTML, but break our logic
        html = html.Replace("\r", "").Replace("\n", " ");
    
        //now create an Html Agile Doc object
        HtmlDocument doc = new HtmlDocument();
        doc.LoadHtml(html);
    
        //remove comments, head, style and script tags
        foreach (HtmlNode node in doc.DocumentNode.SelectNodes("//comment() | //script | //style | //head") ?? Enumerable.Empty<HtmlNode>())
        {
            node.ParentNode.RemoveChild(node);
        }
    
        //now remove all "meaningless" inline elements like "span"
        foreach (HtmlNode node in doc.DocumentNode.SelectNodes("//span | //label") ?? Enumerable.Empty<HtmlNode>()) //add "b", "i" if required
        {
            node.ParentNode.ReplaceChild(HtmlNode.CreateNode(node.InnerHtml), node);
        }
    
        //block-elements - convert to line-breaks
        foreach (HtmlNode node in doc.DocumentNode.SelectNodes("//p | //div") ?? Enumerable.Empty<HtmlNode>()) //you could add more tags here
        {
            //we add a "\n" ONLY if the node contains some plain text as "direct" child
            //meaning - text is not nested inside children, but only one-level deep
    
            //use XPath to find direct "text" in element
            var txtNode = node.SelectSingleNode("text()");
    
            //no "direct" text - NOT ADDDING the \n !!!!
            if (txtNode == null || txtNode.InnerHtml.Trim() == "") continue;
    
            //"surround" the node with line breaks
            node.ParentNode.InsertBefore(doc.CreateTextNode("\r\n"), node);
            node.ParentNode.InsertAfter(doc.CreateTextNode("\r\n"), node);
        }
    
        //todo: might need to replace multiple "\n\n" into one here, I'm still testing...
    
        //now BR tags - simply replace with "\n" and forget
        foreach (HtmlNode node in doc.DocumentNode.SelectNodes("//br") ?? Enumerable.Empty<HtmlNode>())
            node.ParentNode.ReplaceChild(doc.CreateTextNode("\r\n"), node);
    
        //finally - return the text which will have our inserted line-breaks in it
        return WebUtility.HtmlDecode(doc.DocumentNode.InnerText.Trim());
    
        //todo - you should probably add "&code;" processing, to decode all the &nbsp; and such
    }
    

    【讨论】:

      猜你喜欢
      • 2020-05-15
      • 1970-01-01
      • 2018-08-22
      • 2011-10-04
      • 2012-09-23
      • 2012-01-28
      • 2014-08-05
      • 2015-12-03
      相关资源
      最近更新 更多