blocks|key|1422442|text|也许，这根本无关紧要。阅读这篇关于编码恐怖的文章;)：http://www.codinghorror.com/blog/archives/001218.html|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1422443|entityMap|0|LINK|mutability|MUTABLE|url|http://www.codinghorror.com/blog/archives/001218.html^0|R|1H|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Probably, it will not matter at all. Read this post on Coding Horror ;): <a href="http://www.codinghorror.com/blog/archives/001218.html" rel="noreferrer">http://www.codinghorror.com/blog/archives/001218.html</a>

blocks|key|1422621|text|Contains(s2)比IndexOf(s2)快很多倍(在我的电脑中是10倍)，因为Contains使用的StringComparison.Ordinal比IndexOf在默认情况下执行的区分区域性的搜索更快(但在.net+4.0+http://davesbox.com/archive/2008/11/12/breaking-changes-to-the-string-class.aspx中可能会发生变化)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1422622|在我的测试中，Contains的性能与IndexOf(s2，StringComparison.Ordinal)+>=+0完全相同，但它更短，而且让你的意图更清晰。|1422623|entityMap|0|LINK|mutability|MUTABLE|url|http://davesbox.com/archive/2008/11/12/breaking-changes-to-the-string-class.aspx^0|39|28|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

Contains(s2) is many times (in my computer 10 times) faster than IndexOf(s2) because Contains uses StringComparison.Ordinal that is faster than the culture sensitive search that IndexOf does by default (but that may change in .net 4.0 <a href="http://davesbox.com/archive/2008/11/12/breaking-changes-to-the-string-class.aspx" rel="noreferrer">http://davesbox.com/archive/2008/11/12/breaking-changes-to-the-string-class.aspx</a>). 

Contains has exactly the same performance as IndexOf(s2,StringComparison.Ordinal) >= 0 in my tests but it's shorter and makes your intent clear.

blocks|key|1637444|text|通过使用反射器，您可以看到，Contains是使用IndexOf实现的。下面是实现。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1637445|public+bool+Contains(string+value)
{
+++return+(this.IndexOf(value,+StringComparison.Ordinal)+>=+0);
}|code-block|syntax|javascript|1637446|所以Contains可能比直接调用IndexOf慢一点，但我怀疑它对实际性能有任何意义。|1637447|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

By using Reflector, you can see, that Contains is implemented using IndexOf. Here's the implementation.

<pre><code>public bool Contains(string value)
{
 return (this.IndexOf(value, StringComparison.Ordinal) &gt;= 0);
}
</code></pre>

So Contains is likely a wee bit slower than calling IndexOf directly, but I doubt that it will have any significance for the actual performance.

blocks|key|1422563|text|如果你真的想微优化你的代码，你最好的方法总是基准测试。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1422564|System.Diagnostics.Stopwatch是.net框架的一个出色的秒表实现|offset|length|1422565|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/system.diagnostics.stopwatch.aspx^0|0|0|S|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

If you really want to micro optimise your code your best approach is always benchmarking.

The .net framework has an excellent stopwatch implementation - <a href="http://msdn.microsoft.com/en-us/library/system.diagnostics.stopwatch.aspx" rel="nofollow noreferrer">System.Diagnostics.Stopwatch</a>

blocks|key|1637425|text|稍加阅读就会发现，在幕后，String.Contains方法只是调用String.IndexOf。不同之处在于，String.Contains返回一个布尔值，而String.IndexOf返回一个带(-1)的整数，表示没有找到该子字符串。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1637426|我建议写一个大约100,000次迭代的小测试，然后自己看看。如果要我猜的话，我会说IndexOf可能会稍微快一点，但就像我说的那样，这只是一个猜测。|1637427|Jeff+Atwood在his+blog上有一篇关于字符串的好文章。它更多的是关于连接，但可能还是有帮助的。|offset|length|1637428|entityMap|0|LINK|mutability|MUTABLE|url|http://www.codinghorror.com/blog/archives/001218.html^0|0|0|C|8|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@$F|S|G|T|1|U]]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

From a little reading, it appears that under the hood the String.Contains method simply calls String.IndexOf. The difference is String.Contains returns a boolean while String.IndexOf returns an integer with (-1) representing that the substring was not found. 

I would suggest writing a little test with 100,000 or so iterations and see for yourself. If I were to guess, I'd say that IndexOf may be slightly faster but like I said it just a guess. 

Jeff Atwood has a good article on strings at <a href="http://www.codinghorror.com/blog/archives/001218.html" rel="nofollow noreferrer">his blog</a>. It's more about concatenation but may be helpful nonetheless.

blocks|key|1637591|text|作为对此的更新，我已经做了一些测试，假设您的输入字符串相当大，那么并行正则表达式是我发现的最快的C#方法(假设您有多个内核，我想)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1637592|获取匹配的总数例如-|1637593|needles.AsParallel+(+).Sum+(+l+=>+Regex.IsMatch+(+haystack+,+Regex.Escape+(+l+)+)+?+1+:+0+);|code-block|syntax|javascript|1637594|希望这能有所帮助！|1637595|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Just as an update to this I've been doing some testing and providing your input string is fairly large then parallel Regex is the fastest C# method I've found (providing you have more than one core I imagine)

Getting the total amount of matches for example -

<pre><code>needles.AsParallel ( ).Sum ( l =&gt; Regex.IsMatch ( haystack , Regex.Escape ( l ) ) ? 1 : 0 );
</code></pre>

Hope this helps!

blocks|key|1422493|text|使用像this+recent+foray+from+Jon+Skeet这样的基准库来衡量它。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1422494|Caveat+Emptor|1422495|作为所有(微)性能问题，这取决于您正在使用的软件版本、被检查的数据的详细信息以及围绕调用的代码。|1422496|作为所有(微)性能问题，第一步必须获得一个易于维护的运行版本。然后，可以将基准测试、性能分析和调优应用于测量的瓶颈，而不是猜测。|1422497|entityMap|0|LINK|mutability|MUTABLE|url|http://msmvps.com/blogs/jon_skeet/archive/2009/01/26/benchmarking-made-easy.aspx|1|http://en.wikipedia.org/wiki/Caveat_emptor^0|3|W|0|0|0|D|1|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@$A|U|B|V|1|W]]|C|$]]|$1|D|3|E|5|6|7|X|8|@]|9|@$A|Y|B|Z|1|10]]|C|$]]|$1|F|3|G|5|6|7|11|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|12|8|@]|9|@]|C|$]]|$1|J|3|-4|5|6|7|13|8|@]|9|@]|C|$]]]|K|$L|$5|M|N|O|C|$P|Q]]|R|$5|M|N|O|C|$P|S]]]]

Use a benchmark library, like <a href="http://msmvps.com/blogs/jon_skeet/archive/2009/01/26/benchmarking-made-easy.aspx" rel="nofollow noreferrer">this recent foray from Jon Skeet</a> to measure it.

<h3><a href="http://en.wikipedia.org/wiki/Caveat_emptor" rel="nofollow noreferrer">Caveat Emptor</a></h3>

As all (micro-)performance questions, this depends on the versions of software you are using, the details of the data inspected and the code surrounding the call.

As all (micro-)performance questions, the first step has to be to get a running version which is easily maintainable. Then benchmarking, profiling and tuning can be applied to the measured bottlenecks instead of guessing.

blocks|key|1637729|text|今天我在一个1.3+GB的文本文件上试了一下。其中，检查每一行是否存在“@”字符。17.000.000调用Contains/IndexOf。结果:所有包含(‘@’)调用为12.5秒，所有IndexOf('@')调用为2.5秒。=>+IndexOf的执行速度提高了5倍！！(.Net+4.8)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1637730|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Tried it today on a 1.3 GB text file. Amongst others every line is checked for existence of a '@' char. 17.000.000 calls to Contains/IndexOf are made. Result: 12.5 sec for all Contains('@') calls, 2.5 sec for all IndexOf('@') calls. =&gt; IndexOf performs 5 times faster!! (.Net 4.8)

blocks|key|1637645|text|对于任何还在阅读本文的人来说，indexOf()在大多数企业系统上可能会执行得更好，因为contains()与IE不兼容！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1637646|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

For anyone still reading this, indexOf() will probably perform better on most enterprise systems, as contains() is not compatible with IE!

I have a string buffer of about 2000 characters and need to check the buffer if it contains a specific string. 
Will do the check in a ASP.NET 2.0 webapp for every webrequest. 

Does anyone know if the <a href="http://msdn.microsoft.com/en-us/library/dy85x1sa(VS.80).aspx" rel="noreferrer">String.Contains method</a> performs better than <a href="http://msdn.microsoft.com/en-us/library/system.string.indexof(VS.80).aspx" rel="noreferrer">String.IndexOf method</a>? 

<pre><code> // 2000 characters in s1, search token in s2
 string s1 = "Many characters. The quick brown fox jumps over the lazy dog"; 
 string s2 = "fox";
 bool b;
 b = s1.Contains(s2);
 int i;
 i = s1.IndexOf(s2);
</code></pre>

<a href="http://www.cl.cam.ac.uk/~mgk25/ucs/examples/quickbrown.txt" rel="noreferrer">Fun fact</a>

Is String.Contains() faster than String.IndexOf()?

我有一个大约2000个字符的字符串缓冲区，需要检查缓冲区是否包含特定的字符串。将在ASP.NET 2.0 the应用程序中为每个the请求执行检查。有没有人知道的性能是否优于String.IndexOf方法(    // 2000 characters in s1, search token in s2    string s1 = "Many characters. The quick brow

问String.Contains()比String.IndexOf()快吗？
EN

回答 9

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问String.Contains()比String.IndexOf()快吗？EN

回答 9

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问String.Contains()比String.IndexOf()快吗？
EN