为什么使用Linq?

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

这是完美的工作，并接受任何IEnumerable<string>，据我所知。不需要在这里聚合任何东西，这是非常慢的。

当我使用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()
    ;

我代码中的真实例子:

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

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

我要稍微欺骗一下，给出一个新的答案，它似乎总结了这里所有最好的东西，而不是把它粘在注释里。

你可以这样一行:

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的答案可能会稍微更好一些，我不确定Replace与Remove相比在底层做了什么。唯一的另一个警告是，如果你想连接以\a结尾的字符串，你会失去分隔符…我觉得这不太可能。如果是这样的话，你还有其他奇特的角色可以选择。

所谓“超级酷的LINQ方式”，你可能是在谈论LINQ通过使用扩展方法使函数式编程变得更容易接受的方式。我的意思是，允许函数以视觉上的线性方式(一个接一个)链接而不是嵌套(一个在另一个中)的语法糖。例如:

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

可以这样写:

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

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

很多其他答案都说字符串。Join是正确的方法，因为它是最快或最简单的阅读方式。但如果你接受我对“超级酷的LINQ方式”的解释，那么答案是使用字符串。连接，但要将它包装在LINQ风格的扩展方法中，这将允许您以一种视觉上令人愉悦的方式连接函数。如果你想写sa。Concatenate("， ")你只需要创建这样的东西:

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

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

StringBuilder vs Select & Aggregate case超过3000个元素的快速性能数据:

单元测试——持续时间(秒) LINQ_StringBuilder - 0.0036644 LINQ_Select。聚合- 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);
    }