使用 LINQ 连接字符串

Question

在 LINQ 中编写老式的：

StringBuilder sb = new StringBuilder();
if (strings.Count > 0)
{
    foreach (string s in strings)
    {
        sb.Append(s + ", ");
    }
    sb.Remove(sb.Length - 2, 2);
}
return sb.ToString();

... 的最有效方法是什么？

Answer 1

这是我在查看其他答案和类似问题中解决的问题后决定采用的组合 Join/Linq 方法（即聚合和连接因 0 个元素而失败）。

string Result = String.Join(",", split.Select(s => s.Name));

或（如果 s 不是字符串）

string Result = String.Join(",", split.Select(s => s.ToString()));

• 简单
• 易读和理解
• 的通用元素
• 允许使用对象或对象属性
• 处理0 长度元素的情况
• 可以与额外的 Linq 过滤一起使用，
• 表现良好（至少根据我的经验）
• 不需要（手动）创建额外的对象（例如 StringBuilder）来实现

当然Join 处理了有时会潜入其他方法中的讨厌的最后逗号（for、foreach），这就是我首先寻找 Linq 解决方案的原因。

Answer 2

这里有很多选择。 您可以使用 LINQ 和 StringBuilder，这样您也可以获得性能，如下所示：

StringBuilder builder = new StringBuilder();
List<string> MyList = new List<string>() {"one","two","three"};

MyList.ForEach(w => builder.Append(builder.Length > 0 ? ", " + w : w));
return builder.ToString();

Answer 3

您可以非常有效地将 LINQ 和 string.join() 结合起来。 在这里，我从字符串中删除一个项目。 还有更好的方法可以做到这一点，但这里是：

filterset = String.Join(",",
                        filterset.Split(',')
                                 .Where(f => mycomplicatedMatch(f,paramToMatch))
                       );

Answer 4

在使用 linq 解析 IIS 日志文件时，我做了以下快速而肮脏的操作，它在 100 万行时工作得很好（15 秒），尽管在尝试 200 万行时出现内存不足错误。

    static void Main(string[] args)
    {

        Debug.WriteLine(DateTime.Now.ToString() + " entering main");

        // USED THIS DOS COMMAND TO GET ALL THE DAILY FILES INTO A SINGLE FILE: copy *.log target.log 
        string[] lines = File.ReadAllLines(@"C:\Log File Analysis\12-8 E5.log");

        Debug.WriteLine(lines.Count().ToString());

        string[] a = lines.Where(x => !x.StartsWith("#Software:") &&
                                      !x.StartsWith("#Version:") &&
                                      !x.StartsWith("#Date:") &&
                                      !x.StartsWith("#Fields:") &&
                                      !x.Contains("_vti_") &&
                                      !x.Contains("/c$") &&
                                      !x.Contains("/favicon.ico") &&
                                      !x.Contains("/ - 80")
                                 ).ToArray();

        Debug.WriteLine(a.Count().ToString());

        string[] b = a
                    .Select(l => l.Split(' '))
                    .Select(words => string.Join(",", words))
                    .ToArray()
                    ;

        System.IO.File.WriteAllLines(@"C:\Log File Analysis\12-8 E5.csv", b);

        Debug.WriteLine(DateTime.Now.ToString() + " leaving main");

    }

我使用 linq 的真正原因是为了我之前需要的 Distinct() ：

string[] b = a
    .Select(l => l.Split(' '))
    .Where(l => l.Length > 11)
    .Select(words => string.Format("{0},{1}",
        words[6].ToUpper(), // virtual dir / service
        words[10]) // client ip
    ).Distinct().ToArray()
    ;

Answer 5

FWIW 我使用 BDN 对 15 个字符串的字符串数组进行了 string.Join 与 .Aggregate 的基准测试：

Method	Mean	Error	StdDev	Gen0	Alulated
String_Join	92.99 ns	9.905 ns	0.543 ns	0.0560	352 B
LING_Aggregate	406.00 ns	74.662 ns	4.092 ns	0.4640	2912 B

阵列越大，差距越大

Answer 6

我不久前在博客上谈到了这一点，我所做的正是您正在寻找的：

http://ondevelopment.blogspot.com/2009/02/string-concatenation-made-easy.html

在博客文章中描述如何实现适用于 IEnumerable 和被命名为 Concatenate，这将允许您编写如下内容：

var sequence = new string[] { "foo", "bar" };
string result = sequence.Concatenate();

或更复杂的内容，例如：

var methodNames = typeof(IFoo).GetMethods().Select(x => x.Name);
string result = methodNames.Concatenate(", ");

Answer 7

return string.Join(", ", strings.ToArray());

---

在 .Net 4 中，字符串有一个新的重载。 Join 接受 IEnumerable。 代码将如下所示：

return string.Join(", ", strings);

Answer 8

为什么使用 Linq？

string[] s = {"foo", "bar", "baz"};
Console.WriteLine(String.Join(", ", s));

据我所知，它完美地工作并接受任何 IEnumerable 。 这里不需要聚合任何东西，这要慢得多。

Answer 9

您看过聚合扩展方法吗？

var sa = (new[] { "yabba", "dabba", "doo" }).Aggregate((a,b) => a + "," + b);

Answer 10

我的代码中的真实示例：

return selected.Select(query => query.Name).Aggregate((a, b) => a + ", " + b);

查询是一个具有 Name 属性的对象，该属性是一个字符串，我想要所选列表上所有查询的名称，以逗号分隔。

Answer 11

此答案显示了问题中要求的 LINQ (Aggregate) 的用法，并不适合日常使用。 因为这不使用 StringBuilder，所以对于很长的序列来说，它的性能会很糟糕。 对于常规代码，请使用 String.Join，如其他答案

使用聚合像这样的查询：

string[] words = { "one", "two", "three" };
var res = words.Aggregate(
   "", // start with empty string to handle empty list case.
   (current, next) => current + ", " + next);
Console.WriteLine(res);

输出：

, one, two, three

聚合是一个函数，它接受值的集合并返回标量值。 T-SQL 的示例包括最小值、最大值和总和。 VB 和 C# 都支持聚合。 VB 和 C# 都支持聚合作为扩展方法。 使用点表示法，只需调用 IEnumerable< 上的方法即可/a> 对象。

请记住，聚合查询会立即执行。

详细信息 - MSDN：聚合查询

---

如果您确实想使用 Aggregate 使用 StringBuilder 使用变体>CodeMonkeyKing 与常规 String.Join 的代码大致相同，包括对大量对象的良好性能：

 var res = words.Aggregate(
     new StringBuilder(), 
     (current, next) => current.Append(current.Length == 0? "" : ", ").Append(next))
     .ToString();

Answer 12

StringBuilder 与 Select 和 Select 的快速性能数据 超过 3000 个元素的聚合案例：

单元测试 - 持续时间（秒）
LINQ_StringBuilder - 0.0036644
LINQ_Select.Aggregate - 1.8012535

    [TestMethod()]
    public void LINQ_StringBuilder()
    {
        IList<int> ints = new List<int>();
        for (int i = 0; i < 3000;i++ )
        {
            ints.Add(i);
        }
        StringBuilder idString = new StringBuilder();
        foreach (int id in ints)
        {
            idString.Append(id + ", ");
        }
    }
    [TestMethod()]
    public void LINQ_SELECT()
    {
        IList<int> ints = new List<int>();
        for (int i = 0; i < 3000; i++)
        {
            ints.Add(i);
        }
        string ids = ints.Select(query => query.ToString())
                         .Aggregate((a, b) => a + ", " + b);
    }

Answer 13

您可以在 Aggregate 中使用 StringBuilder：（

  List<string> strings = new List<string>() { "one", "two", "three" };

  StringBuilder sb = strings
    .Select(s => s)
    .Aggregate(new StringBuilder(), (ag, n) => ag.Append(n).Append(", "));

  if (sb.Length > 0) { sb.Remove(sb.Length - 2, 2); }

  Console.WriteLine(sb.ToString());

其中的 Select 只是为了表明您可以执行更多 LINQ 操作。）

Answer 14

我将稍微作弊并给出一个新的答案，它似乎总结了这里最好的一切，而不是把它放在评论中。

因此，您可以这样一行：

List<string> strings = new List<string>() { "one", "two", "three" };

string concat = strings        
    .Aggregate(new StringBuilder("\a"), 
                    (current, next) => current.Append(", ").Append(next))
    .ToString()
    .Replace("\a, ",string.Empty); 

编辑：您要么想首先检查空枚举，要么添加.Replace("\a",string.Empty); 到表达式的末尾。 我想我可能是想变得有点太聪明了。

@a.friend 的答案可能性能稍好一些，我不确定替换与删除相比在幕后做了什么。 唯一的其他警告，如果出于某种原因你想连接以 \a 结尾的字符串，你会丢失分隔符......我发现这不太可能。 如果是这种情况，您确实有 其他奇特的角色可供选择。

Answer 15

这里它使用纯 LINQ 作为单个表达式：

static string StringJoin(string sep, IEnumerable<string> strings) {
  return strings
    .Skip(1)
    .Aggregate(
       new StringBuilder().Append(strings.FirstOrDefault() ?? ""), 
       (sb, x) => sb.Append(sep).Append(x));
}

而且速度非常快！

Answer 16

通过“超级酷的 LINQ 方式”，您可能会谈论 LINQ 通过使用扩展方法使函数式编程变得更加容易接受的方式。 我的意思是，语法糖允许函数以视觉上线性的方式链接（一个接一个），而不是嵌套（一个在另一个里面）。 例如：

int totalEven = Enumerable.Sum(Enumerable.Where(myInts, i => i % 2 == 0));

可以这样写：

int totalEven = myInts.Where(i => i % 2 == 0).Sum();

你可以看到第二个例子如何更容易阅读。 您还可以看到如何添加更多函数，同时减少缩进问题或表达式末尾出现的 Lispy 右括号。

许多其他答案都指出 String.Join 是可行的方法，因为它是最快或最简单的读取方式。 但是，如果您接受我对“超酷 LINQ 方式”的解释，那么答案是使用 String.Join，但将其包装在 LINQ 样式扩展方法中，这样可以允许您可以以视觉上令人愉悦的方式链接您的功能。 因此，如果您想编写 sa.Concatenate(", ") 您只需创建如下内容：

public static class EnumerableStringExtensions
{
   public static string Concatenate(this IEnumerable<string> strings, string separator)
   {
      return String.Join(separator, strings);
   }
}

这将提供与直接调用一样高性能的代码（至少在算法复杂性方面） ）并且在某些情况下可能会使代码更具可读性（取决于上下文），特别是当块中的其他代码使用链式函数样式时。

Answer 17

我总是使用扩展方法：

public static string JoinAsString<T>(this IEnumerable<T> input, string seperator)
{
    var ar = input.Select(i => i.ToString());
    return string.Join(seperator, ar);
}