使用LINQ连接字符串

Question

写老派最有效的方法是什么:

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();

......在LINQ？

Answer 1

这个答案显示Aggregate了问题中所要求的LINQ()的使用,并不适合日常使用.因为这不使用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的示例包括min,max和sum.VB和C#都支持聚合.VB和C#都支持聚合作为扩展方法.使用点符号,只需调用IEnumerable对象上的方法即可.

请记住,聚合查询会立即执行.

更多信息 - MSDN:聚合查询

如果你真的想使用CodeMonkeyKing在评论中提出的Aggregate使用变体,它将与常规代码相同,包括对大量对象的良好性能:StringBuilderString.Join

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

Answer 2

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

在.NET 4中,有一个新的过载为string.Join接受IEnumerable<string>.然后代码看起来像:

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

Answer 3

为什么要使用Linq？

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

这完美地运作并且IEnumerable<string>在我记忆中接受任何.Aggregate这里不需要任何慢一点的东西.

Answer 4

你看过Aggregate扩展方法了吗？

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

Answer 5

我的代码中的真实示例:

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

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

Answer 6

您可以使用StringBuilder在Aggregate:

  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 7

以下是我在查看其他答案和在类似问题中解决的问题(即Aggregate和Concatenate失败的0个元素)后确定的Join/Linq组合方法.

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 8

StringBuilder的快速性能数据与超过3000个元素的Select&Aggregate案例:

单元测试 - 持续时间(秒)
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 9

我总是使用扩展方法:

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

Answer 10

通过' 超酷的LINQ方式 ',您可能会谈到LINQ使用扩展方法使函数式编程变得更加可口的方式.我的意思是,语法糖允许函数以视觉线性方式(一个接一个)链接而不是嵌套(一个在另一个内).例如:

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

可以像这样写:

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

您可以看到第二个示例如何更容易阅读.您还可以看到如何添加更多函数,减少压痕问题或表达式末尾出现的Lispy闭合parens.

许多其他答案表明这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 11

在前一个问题上有各种可供选择的答案- 诚然,它以整数数组作为源,但收到了广义答案.

Answer 12

这里使用纯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));
}

它非常快!