获取 XElement 的 InnerXml 的最佳方法？

Question

在下面的代码中获取混合body元素内容的最佳方法是什么？ 该元素可能包含 XHTML 或文本，但我只想要字符串形式的内容。 XmlElement类型具有InnerXml属性，这正是我所追求的。

所编写的代码几乎可以满足我的要求，但包括周围的<body> ... </body>元素，这是我不想要的。

XDocument doc = XDocument.Load(new StreamReader(s));
var templates = from t in doc.Descendants("template")
                where t.Attribute("name").Value == templateName
                select new
                {
                   Subject = t.Element("subject").Value,
                   Body = t.Element("body").ToString()
                };

Answer 1

我想看看这些建议的解决方案中哪一个表现最好，所以我进行了一些比较测试。 出于兴趣，我还将 LINQ 方法与 Greg 建议的普通旧System.Xml方法进行了比较。 这种变化很有趣，并不是我所期望的，最慢的方法比最快的方法慢3 倍以上。

结果按最快到最慢排序：

1. CreateReader - Instance Hunter（0.113 秒）
2. 普通的旧 System.Xml - Greg Hurlman（0.134 秒）
3. 使用字符串串联聚合 - Mike Powell（0.324 秒）
4. StringBuilder - Vin（0.333 秒）
5. String.Join on array - Terry（0.360 秒）
6. 数组上的 String.Concat - Marcin Kosieradzki (0.364)

---

方法

我使用了一个带有 20 个相同节点（称为“提示”）的 XML 文档：

<hint>
  <strong>Thinking of using a fake address?</strong>
  <br />
  Please don't. If we can't verify your address we might just
  have to reject your application.
</hint>

上面显示的秒数是提取 20 个节点的“内部 XML”，连续 1000 次，并取 5 次运行的平均值（平均值）的结果。 我没有包括将 XML 加载并将其解析为XmlDocument （对于System.Xml方法）或XDocument （对于所有其他方法）所花费的时间。

我使用的 LINQ 算法是： （C# - 都采用XElement “父”并返回内部 XML 字符串）

创建阅读器：

var reader = parent.CreateReader();
reader.MoveToContent();

return reader.ReadInnerXml();

用字符串连接聚合：

return parent.Nodes().Aggregate("", (b, node) => b += node.ToString());

字符串生成器：

StringBuilder sb = new StringBuilder();

foreach(var node in parent.Nodes()) {
    sb.Append(node.ToString());
}

return sb.ToString();

String.Join 数组：

return String.Join("", parent.Nodes().Select(x => x.ToString()).ToArray());

数组上的 String.Concat：

return String.Concat(parent.Nodes().Select(x => x.ToString()).ToArray());

我没有在这里展示“Plain old System.Xml”算法，因为它只是在节点上调用 .InnerXml 。

---

结论

如果性能很重要（例如大量 XML，经常解析），我每次都会使用 Daniel 的CreateReader方法。 如果您只是进行一些查询，您可能希望使用 Mike 更简洁的 Aggregate 方法。

如果您在具有大量节点（可能有 100 个）的大型元素上使用 XML，您可能会开始看到使用StringBuilder而不是 Aggregate 方法的好处，但不是CreateReader 。 我不认为Join和Concat方法在这些情况下会更有效，因为将大列表转换为大数组会带来损失（即使在这里使用较小的列表也很明显）。

Answer 2

我认为这是一个更好的方法（在 VB 中，应该不难翻译）：

给定一个 XElement x：

Dim xReader = x.CreateReader
xReader.MoveToContent
xReader.ReadInnerXml

Answer 3

在 XElement 上使用这个“扩展”方法怎么样？ 为我工作！

public static string InnerXml(this XElement element)
{
    StringBuilder innerXml = new StringBuilder();

    foreach (XNode node in element.Nodes())
    {
        // append node's xml string to innerXml
        innerXml.Append(node.ToString());
    }

    return innerXml.ToString();
}

或者使用一点 Linq

public static string InnerXml(this XElement element)
{
    StringBuilder innerXml = new StringBuilder();
    doc.Nodes().ToList().ForEach( node => innerXml.Append(node.ToString()));

    return innerXml.ToString();
}

注意：上面的代码必须使用element.Nodes()而不是element.Elements() 。 记住两者之间的区别非常重要。 element.Nodes()为您提供XText 、 XAttribute等所有内容，但XElement只是一个元素。

Answer 4

感谢那些发现并证明了最佳方法的人（谢谢！），这里将它封装在一个扩展方法中：

public static string InnerXml(this XNode node) {
    using (var reader = node.CreateReader()) {
        reader.MoveToContent();
        return reader.ReadInnerXml();
    }
}

Answer 5

保持简单和高效：

String.Concat(node.Nodes().Select(x => x.ToString()).ToArray())

• 连接字符串时，聚合是内存和性能低效的
• 使用 Join("", sth) 是使用比 Concat 大两倍的字符串数组......而且在代码中看起来很奇怪。
• 使用 += 看起来很奇怪，但显然并不比使用 '+' 差多少 - 可能会优化为相同的代码，因为分配结果未使用并且可能被编译器安全删除。
• StringBuilder 非常必要——每个人都知道不必要的“状态”很糟糕。

Answer 6

我最终使用了这个：

Body = t.Element("body").Nodes().Aggregate("", (b, node) => b += node.ToString());

Answer 7

就个人而言，我最终使用 Aggregate 方法编写了一个InnerXml扩展方法：

public static string InnerXml(this XElement thiz)
{
   return thiz.Nodes().Aggregate( string.Empty, ( element, node ) => element += node.ToString() );
}

我的客户端代码就像使用旧的 System.Xml 命名空间一样简洁：

var innerXml = myXElement.InnerXml();

Answer 8

@Greg：看来您已将答案编辑为完全不同的答案。 我的回答是肯定的，我可以使用 System.Xml 来做到这一点，但我希望能用 LINQ to XML 弄湿我的脚。

我会在下面留下我的原始回复，以防其他人想知道为什么我不能只使用 XElement 的 .Value 属性来获得我需要的东西：

@Greg：Value 属性连接任何子节点的所有文本内容。 因此，如果 body 元素仅包含文本，则它可以工作，但如果它包含 XHTML，我会将所有文本连接在一起，但没有任何标签。

Answer 9

// 使用 Regex 可能更快地简单地修剪开始和结束元素标签

var content = element.ToString();
var matchBegin = Regex.Match(content, @"<.+?>");
content = content.Substring(matchBegin.Index + matchBegin.Length);          
var matchEnd = Regex.Match(content, @"</.+?>", RegexOptions.RightToLeft);
content = content.Substring(0, matchEnd.Index);

Answer 10

doc.ToString() 或 doc.ToString(SaveOptions) 完成这项工作。 请参阅http://msdn.microsoft.com/en-us/library/system.xml.linq.xelement.tostring(v=vs.110).aspx

Answer 11

你懂？ 最好的办法是回到 CDATA :( 我在这里查看解决方案，但我认为 CDATA 是迄今为止最简单和最便宜的，而不是最方便的开发方法

Answer 12

是否可以使用 System.Xml 命名空间对象来完成这里的工作而不是使用 LINQ？ 正如您已经提到的，XmlNode.InnerXml 正是您所需要的。

Answer 13

var innerXmlAsText= XElement.Parse(xmlContent)
                    .Descendants()
                    .Where(n => n.Name.LocalName == "template")
                    .Elements()
                    .Single()
                    .ToString();

会为你做这项工作

Answer 14

想知道是否（注意我去掉了 b+= 而只有 b+）

t.Element( "body" ).Nodes()
 .Aggregate( "", ( b, node ) => b + node.ToString() );

效率可能略低于

string.Join( "", t.Element.Nodes()
                  .Select( n => n.ToString() ).ToArray() );

不是 100% 确定......但是在 Reflector 中瞥了一眼 Aggregate() 和 string.Join() ......我想我把它读为 Aggregate 只是附加了一个返回值，所以基本上你得到：

字符串 = 字符串 + 字符串

与 string.Join 相比，它在那里提到了 FastStringAllocation 或其他东西，这让我觉得微软的人可能会在那里增加一些额外的性能提升。 当然，我的 .ToArray() 调用我的否定，但我只是想提供另一个建议。

Answer 15

public static string InnerXml(this XElement xElement)
{
    //remove start tag
    string innerXml = xElement.ToString().Trim().Replace(string.Format("<{0}>", xElement.Name), "");
    ////remove end tag
    innerXml = innerXml.Trim().Replace(string.Format("</{0}>", xElement.Name), "");
    return innerXml.Trim();
}