我正在做一些事情，我意识到我想要在一个字符串中找到多少个/s，然后我突然想到，有几种方法可以做到这一点，但不能决定哪种是最好的(或最简单的)。
目前我想说的是:
string source = "/once/upon/a/time/";
int count = source.Length - source.Replace("/", "").Length;
但我一点都不喜欢，有人愿意吗?
我并不想为此挖掘出正则表达式，对吧?
我知道我的字符串将包含我要搜索的项，所以你可以假设…
当然对于长度为> 1的字符串，
string haystack = "/once/upon/a/time";
string needle = "/";
int needleCount = ( haystack.Length - haystack.Replace(needle,"").Length ) / needle.Length;
当前回答
从。Net 5 (Net core 2.1+和NetStandard 2.1)开始，我们有了一个新的迭代速度之王。
“跨度<T>”https://learn.microsoft.com/en-us/dotnet/api/system.span-1?view=net-5.0
String有一个内置成员，返回Span<Char>
int count = 0;
foreach( var c in source.AsSpan())
{
if (c == '/')
count++;
}
我的测试显示比直刺快62%我还比较了Span<T>[I]上的for()循环，以及这里发布的其他一些内容。注意，String上的反向for()迭代现在似乎比直接foreach运行得慢。
Starting test, 10000000 iterations
(base) foreach = 673 ms
fastest to slowest
foreach Span = 252 ms 62.6%
Span [i--] = 282 ms 58.1%
Span [i++] = 402 ms 40.3%
for [i++] = 454 ms 32.5%
for [i--] = 867 ms -28.8%
Replace = 1905 ms -183.1%
Split = 2109 ms -213.4%
Linq.Count = 3797 ms -464.2%
更新:2021年12月，Visual Studio 2022， .NET 5和6
.NET 5
Starting test, 100000000 iterations set
(base) foreach = 7658 ms
fastest to slowest
foreach Span = 3710 ms 51.6%
Span [i--] = 3745 ms 51.1%
Span [i++] = 3932 ms 48.7%
for [i++] = 4593 ms 40.0%
for [i--] = 7042 ms 8.0%
(base) foreach = 7658 ms 0.0%
Replace = 18641 ms -143.4%
Split = 21469 ms -180.3%
Linq = 39726 ms -418.8%
Regex Compiled = 128422 ms -1,577.0%
Regex = 179603 ms -2,245.3%
.NET 6
Starting test, 100000000 iterations set
(base) foreach = 7343 ms
fastest to slowest
foreach Span = 2918 ms 60.3%
for [i++] = 2945 ms 59.9%
Span [i++] = 3105 ms 57.7%
Span [i--] = 5076 ms 30.9%
(base) foreach = 7343 ms 0.0%
for [i--] = 8645 ms -17.7%
Replace = 18307 ms -149.3%
Split = 21440 ms -192.0%
Linq = 39354 ms -435.9%
Regex Compiled = 114178 ms -1,454.9%
Regex = 186493 ms -2,439.7%
我添加了更多的循环，并加入了RegEx，这样我们就可以看到在大量迭代中使用它是一场灾难。 我认为for(++)循环比较可能已经在。net 6中进行了优化，以便在内部使用Span -因为它与foreach Span的速度几乎相同。
代码链接
其他回答
var conditionalStatement = conditionSetting.Value;
//order of replace matters, remove == before =, incase of ===
conditionalStatement = conditionalStatement.Replace("==", "~").Replace("!=", "~").Replace('=', '~').Replace('!', '~').Replace('>', '~').Replace('<', '~').Replace(">=", "~").Replace("<=", "~");
var listOfValidConditions = new List<string>() { "!=", "==", ">", "<", ">=", "<=" };
if (conditionalStatement.Count(x => x == '~') != 1)
{
result.InvalidFieldList.Add(new KeyFieldData(batch.DECurrentField, "The IsDoubleKeyCondition does not contain a supported conditional statement. Contact System Administrator."));
result.Status = ValidatorStatus.Fail;
return result;
}
需要做一些类似于从字符串测试条件语句的事情。
用单个字符替换我正在寻找的内容，并计算单个字符的实例数。
显然，在发生这种情况之前，您需要检查您正在使用的单个字符是否存在于字符串中，以避免错误计数。
如果你想搜索整个字符串，而不仅仅是字符:
src.Select((c, i) => src.Substring(i))
.Count(sub => sub.StartsWith(target))
读为“对于字符串中的每个字符，将该字符开始的字符串的其余部分作为子字符串;如果它以目标字符串开头，就数一数。”
private int CountWords(string text, string word) {
int count = (text.Length - text.Replace(word, "").Length) / word.Length;
return count;
}
因为最初的解决方案，是最快的字符，我想它也将是字符串。这是我的贡献。
上下文:我在日志文件中寻找像“失败”和“成功”这样的词。
克 我
如果你使用的是。net 3.5，你可以用LINQ在一行代码中完成:
int count = source.Count(f => f == '/');
如果你不想使用LINQ，你可以用:
int count = source.Split('/').Length - 1;
您可能会惊讶地发现，您原来的技术似乎比这两种方法都快30% !我刚刚用“/once/upon/a/time/”做了一个快速的基准测试，结果如下:
你的原稿= 12s 源。计数= 19秒 源。分裂= 17秒 Foreach(来自bobwienholt的答案)= 10s
(迭代次数为50,000,000次，因此在现实世界中您不太可能注意到太多差异。)
string source = "/once/upon/a/time/";
int count = 0, n = 0;
while ((n = source.IndexOf('/', n) + 1) != 0) count++;
这是Richard Watson的答案的一个变体，char在字符串中出现的次数越多，效率就会提高一点，代码也会更少!
虽然我必须说，在没有广泛测试每个场景的情况下，我确实看到了使用以下方法的显著速度提升:
int count = 0;
for (int n = 0; n < source.Length; n++) if (source[n] == '/') count++;
