使用LINQ to连接字符串使用LINQ to连接字符串(Using LINQ to concate

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

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:

这个答案显示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的对象。

请记住，聚集查询将立即执行。

更多信息- MSDN：聚集查询

---

如果你真的想用Aggregate使用用变异StringBuilder通过评论提出CodeMonkeyKing这将是大约相同的代码作为普通String.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:

你看，总结推广方法？

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:

以下是结合加入/ LINQ的方法，我在寻找其他的答案后定居在和处理的问题类似的问题 （即聚合并连接失败，0元素）。

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

或（如果s不是字符串）

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

• 简单
• 易于阅读和理解
• 适用于通用元素
• 允许使用对象或对象属性
• 处理长度为0的元件的情况下
• 可以与额外的LINQ滤波来使用
• 执行好（至少在我的经验）
• 不需要额外的对象（例如的（手动）创建StringBuilder ）实施

当然，加入照顾讨厌的最后一个逗号，有时潜入其他方法（的for ， foreach ），这就是为什么我一直在寻找在首位LINQ的解决方案。

Answer 8:

为StringBuilder的VS选择和集料的情况下超过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 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收盘括号来添加。

很多其他的答案中指出的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));
}

而其非常该死的快！

Answer 13:

我要骗一点，并抛出了一个新的答案，这似乎总结出最好的东西放在这里，而不是坚持它的注释里面的。

所以，你可以一行这样的：

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答案可能会稍微更好的性能，我不知道什么替换相比删除引擎盖下做。 唯一的另外一点，如果由于某种原因，你想Concat的是，在\ A的你会失去你的分离结束串......我觉得这不太可能。 如果是这样的话你有其他奇特的字符选择。

Answer 14:

您可以结合LINQ和string.join()相当有效。 在这里，我从一个字符串中删除一个项目。 有太多这样做的更好的方法，但在这里它是：

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

Answer 15:

很多在这里的选择。 您可以使用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 16:

我做了解析使用LINQ的IIS日志文件时，下面的快速和肮脏的，它的工作@ 100万行还算不错（15秒），尽管试图2个百万行的时候得到一个内存不足的错误。

    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的真正原因是为一个独特的（）我以前neede：

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 17:

我的博客上讲述这一段时间以前，我做了什么接缝是你要寻找什么：

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

在博客文章介绍如何实现扩展方法上IEnumerable的作品，并命名为串联，这将让你写的东西，如：

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

或更复杂的事情，如：

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

文章来源: Using LINQ to concatenate strings