C# 使用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();

---

…在LINQ中？

您看过聚合扩展方法吗

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

为什么要使用Linq

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

---

就我记忆所及，它可以完美地工作并接受任何

IEnumerable

。这里不需要聚合任何慢得多的东西。

我的代码中的真实示例：

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

---

查询是一个具有名称属性（字符串）的对象，我需要所选列表中所有查询的名称，以逗号分隔。

此答案显示了问题中要求的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);

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

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

这将产生：

, one, two, three

---

在这个问题上有各种不同的答案——诚然，它的目标是一个整数数组作为源，但得到了普遍的答案

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

---

在.NET4中，有一个新的for

string.Join

，它接受

IEnumerable

。然后，代码将如下所示：

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

---

我总是使用扩展方法：

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

公共静态字符串JoinAsString（此IEnumerable输入，字符串分隔符）
{
var ar=input.Select（i=>i.ToString（））；
返回字符串.连接（分隔符，ar）；
}

我不久前在博客上写过这件事，我所做的正是你想要的：

在这篇博文中，我们将介绍如何实现在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(", ");

或者更复杂的事情，比如：

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

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

---

这里有很多选择。您可以使用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();

StringBuilder=新建StringBuilder（）；
List MyList=newlist（）{“一”、“二”、“三”}；
MyList.ForEach（w=>builder.Append（builder.Length>0？，“+w:w））；
返回builder.ToString（）；

超过3000个元素的StringBuilder与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);
    }

[TestMethod（）]
公共无效LINQ_StringBuilder（）
{
IList ints=新列表（）；
对于（int i=0；i<3000；i++）
{
内加（i）；
}
StringBuilder idString=新建StringBuilder（）；
foreach（整数中的整数id）
{
idString.Append（id+“，”）；
}
}
[TestMethod（）]
公共无效LINQ_SELECT（）
{
IList ints=新列表（）；
对于（int i=0；i<3000；i++）
{
内加（i）；
}
string id=ints.Select（query=>query.ToString（））
.骨料（（a，b）=>a+“，”+b）；
}

您可以在

聚合中使用
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());

List strings=newlist（）{“一”、“二”、“三”}；
StringBuilder sb=字符串
.选择（s=>s）
.Aggregate（新的StringBuilder（），（ag，n）=>ag.Append（n）.Append（“，”）；
如果（sb.Length>0）{sb.Remove（sb.Length-2,2）；}
Console.WriteLine（sb.ToString（））；

（选择
只是为了显示您可以做更多的LINQ工作。）
您可以非常有效地将LINQ和
string.join（）结合起来。这里我从字符串中删除一个项。也有更好的方法可以做到这一点，但这里是：

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

我要做一点欺骗，并抛出一个新的答案，似乎总结了这里最好的一切，而不是把它放在评论里面

所以你可以用这一行：

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

List strings=newlist（）{“一”、“二”、“三”}；
字符串concat=字符串
.Aggregate（新的StringBuilder（“\a”），
（当前，下一个）=>current.Append（“，”）.Append（下一个））
.ToString（）
.Replace（“\a”，string.Empty）；

编辑：您可以先检查空的可枚举项，或者添加一个
.Replace（“\a”，string.empty）到表达式的末尾。我想我可能是想变得有点太聪明了

@a.friend的回答可能会稍微好一点，我不确定替换引擎盖下的功能与移除相比是什么。唯一的另一个警告是，如果出于某种原因想要压缩以\a结尾的字符串，则会丢失分隔符。。。我觉得不太可能。如果是这种情况，您必须从中进行选择。
在使用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的真正原因是为了一个我以前需要的独特的（）目的：

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

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

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

可以这样写：

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

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

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

您可以看到第二个示例如何更容易阅读。您还可以看到如何添加更多的函数，从而减少缩进问题或表达式末尾出现的Lispy闭包

许多其他答案都指出，
String.Join
是一种方法，因为它是最快或最简单的阅读方式。但是，如果你接受我对“超级酷LINQ方式”的解释，那么答案就是使用
String.Join
，但将其包装在LINQ风格的扩展方法中，这将允许你以一种视觉愉悦的方式链接你的函数。因此，如果您想编写
sa.Concatenate（“，”）
，只需创建如下内容：

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

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

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

公共静态类EnumerableStringExtensions
{
公共静态字符串连接（此IEnumerable字符串，