题
写老派最有效的方法是什么:
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 中?
解决方案
此答案显示问题中请求的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的示例包括min,max和sum。 VB和C#都支持聚合。 VB和C#都支持聚合作为扩展方法。使用点符号,只需在 IEnumerable <上调用方法即可。 / a>对象。
请记住,聚合查询会立即执行。
更多信息 - MSDN:Aggregate查询
如果你真的想使用<=>使用 CodeMonkeyKing 评论中提出的<=>关于与常规<=>相同的代码,包括对大量对象的良好性能:
var res = words.Aggregate(
new StringBuilder(),
(current, next) => current.Append(current.Length == 0? "" : ", ").Append(next))
.ToString();
其他提示
return string.Join(", ", strings.ToArray());
在.Net 4中,重载 > string.Join
,接受 IEnumerable&lt; string&gt;
。然后代码如下:
return string.Join(", ", strings);
为什么要使用Linq?
string[] s = {"foo", "bar", "baz"};
Console.WriteLine(String.Join(", ", s));
完美无缺,并且在我记忆中接受任何 IEnumerable&lt; string&gt;
。不需要聚合
这里的任何东西都要慢得多。
你看过Aggregate扩展方法吗?
var sa = (new[] { "yabba", "dabba", "doo" }).Aggregate((a,b) => a + "," + b);
我的代码中的真实示例:
return selected.Select(query => query.Name).Aggregate((a, b) => a + ", " + b);
查询是一个具有Name属性的对象,该属性是一个字符串,我想要所选列表中所有查询的名称,以逗号分隔。
您可以在 Aggregate
中使用 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());
( Select
就在那里,只是为了表明你可以做更多LINQ的东西。)
这是我在查看其他答案和解决的问题后决定采用的组合 Join/Linq 方法 在类似的问题中 (即聚合和连接因 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 解决方案的原因。
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);
}
我总是使用扩展方法:
public static string JoinAsString<T>(this IEnumerable<T> input, string seperator)
{
var ar = input.Select(i => i.ToString()).ToArray();
return string.Join(seperator, ar);
}
通过'超酷的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(&quot;,&quot;)
,你只需要创建这样的东西:
public static class EnumerableStringExtensions
{
public static string Concatenate(this IEnumerable<string> strings, string separator)
{
return String.Join(separator, strings);
}
}
这将提供与直接调用一样高效的代码(至少在算法复杂性方面),并且在某些情况下可以使代码更具可读性(取决于上下文),尤其是如果块中的其他代码正在使用链式功能风格。
有各种备选答案。上一个问题 - 无可否认地将整数数组作为源,但收到了广义答案。
这里使用纯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));
}
它的速度非常快!
我将稍微作弊并给出一个新的答案,它似乎总结了这里最好的一切,而不是把它放在评论中。
所以你可以这样写:
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 结尾的字符串,你会丢失分隔符......我觉得这不太可能。如果是这种情况,你确实有 其他奇特的角色 从中选择。
您可以非常有效地组合LINQ和 string.join()
。这里我从字符串中删除一个项目。有更好的方法可以做到这一点,但现在是:
filterset = String.Join(",",
filterset.Split(',')
.Where(f => mycomplicatedMatch(f,paramToMatch))
);
这里有很多选择。您可以使用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();
在使用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("/cstring[] 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()
;
quot;) &&
!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:
<*>我刚才在博客上写过这篇文章,我所做的接缝正是你所寻找的:
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(", ");