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

此答案显示问题中请求的LINQ（Aggregate）的使用情况，不适合日常使用。因为这不使用StringBuilder，所以对于很长的序列来说它会有很糟糕的表现。对于常规代码，请使用其他answer

中显示的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: Aggregate Queries

如果您真的想使用Aggregate，请使用CodeMonkeyKing评论中提出的StringBuilder使用变体，该变体与常规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>的新overload。然后代码如下：

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

以下是我在查看其他答案和问题in a similar question后确定的Join / Linq方法的结合（即Aggregate和Concatenate失败并带有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解决方案的原因。< / p>

Answer 7

您可以在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 8

StringBuilder与Select＆amp; amp;的快速性能数据聚合案例超过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 关闭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

这里使用纯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 12

这个previous question有各种替代答案 - 无可否认地将整数数组作为来源，但收到了广义答案。

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的答案可能稍微高一些，我不确定与删除相比，引擎盖下的替换功能。唯一的另一个警告，如果某些原因你想要连接以\ a结尾的字符串，你会失去你的分隔符...我发现这不太可能。如果是这种情况，您可以选择other fancy characters。

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日志文件时，我做了以下快速和肮脏的工作，虽然在尝试2百万行时出现了内存不足错误，但它工作了100万行（15秒）。

    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（）我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的扩展方法，并命名为Concatenate，这将让你写出如下内容：

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

或者更精细的事情：

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

使用LINQ连接字符串

17 个答案: