C# 中的字符串比较性能

发布于 2024-07-20 06:02:55 字数 520 浏览 7 评论 0原文

有多种方法可以比较字符串。采取一种方式比另一种方式是否能带来性能提升？

我总是选择像这样比较字符串：

string name = "Bob Wazowski";
if (name.CompareTo("Jill Yearsley") == 0) {
    // whatever...
}

但我发现很少有人这样做，如果有的话，我看到更多的人只是做直接 == 比较，据我所知，这是比较字符串的最糟糕的方法。我错了吗？

另外，它对 LINQ 查询中的字符串比较方式有影响吗？例如，我喜欢执行以下操作：

var results = from names in ctx.Names
              where names.FirstName.CompareTo("Bob Wazowski") == 0
              select names;

但是，我再次看到很少有人在 LINQ 查询中像这样进行字符串比较。

原文

There are a number of ways to compare strings. Are there performance gains by doing one way over another?

I've always opted to compare strings like so:

string name = "Bob Wazowski";
if (name.CompareTo("Jill Yearsley") == 0) {
    // whatever...
}

But I find few people doing this, and if anything, I see more people just doing a straight == comparison, which to my knowledge is the worst way to compare strings. Am I wrong?

Also, does it make a difference in how one compares strings within LINQ queries? For example, I like to do the following:

var results = from names in ctx.Names
              where names.FirstName.CompareTo("Bob Wazowski") == 0
              select names;

But again, I see few people doing string comparisons like so in their LINQ queries.

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

入画浅相思 2024-07-27 06:02:56

根据 Reflector 的说法

"Hello" == "World"

，它

String.Equals("Hello", "World");

基本上确定它们是否是相同的引用对象，如果其中一个为 null，则如果一个为 null 而另一个不是，则自动为 false，然后在不安全循环中比较每个字符。所以它根本不关心文化规则，这通常没什么大不了的。

就

"Hello".CompareTo("World") == 0

功能而言，这基本上是相反的

CultureInfo.CurrentCulture.CompareInfo.Compare("Hello", "World", CompareOptions.None);

。它考虑了文化、编码以及上下文中字符串的所有其他内容。

所以我可以想象 String.CompareTo 比相等运算符慢几个数量级。

至于你的 LINQ，如果你使用 LINQ-to-SQL 并不重要，因为两者都会生成相同的 SQL

var results = from names in ctx.Names
          where names.FirstName.CompareTo("Bob Wazowski") == 0
          select names;

，

SELECT [name fields]
FROM [Names] AS [t0]
WHERE [t0].FirstName = @p0

所以你实际上不会从 LINQ-to-SQL 中获得任何东西，除了更难阅读代码和可能更多的解析的表达方式。如果您只是将 LINQ 用于标准数组，那么我上面列出的规则就适用。

According to Reflector

"Hello" == "World"

is the same as

String.Equals("Hello", "World");

which basically determines if they are the same reference object, if either of them is null, which would be an automatic false if one was null and the other was not, and then compares each character in an unsafe loop. So it doesn't care about cultural rules at all, which usually isn't a big deal.

and

"Hello".CompareTo("World") == 0

is the same as

CultureInfo.CurrentCulture.CompareInfo.Compare("Hello", "World", CompareOptions.None);

This is basically the opposite as far as functionality. It takes into consideration culture, encoding, and everything else with the string in to context.

So I would imagine that String.CompareTo is a couple of orders of magnitude slower than the equality operator.

as for your LINQ it doesn't matter if you are using LINQ-to-SQL because both will generate the same SQL

var results = from names in ctx.Names
          where names.FirstName.CompareTo("Bob Wazowski") == 0
          select names;

SELECT [name fields]
FROM [Names] AS [t0]
WHERE [t0].FirstName = @p0

so you really aren't gaining anything for LINQ-to-SQL except harder to read code and probably more parsing of the expressions. If you are just using LINQ for standard array stuff then the rules I laid out above apply.

回复收藏 0 原文

病毒体 2024-07-27 06:02:56

在我看来，你应该始终使用最清晰的方式，那就是使用 ==！

这可以直接理解为：当“Hello”等于“World”时，则做某事。

if ("Hello" == "World")
    // ...

在内部，会调用 String::Equals ，它是为此目的而显式存在的 - 比较两个字符串是否相等。（这与指针和引用等无关。）

这并不是立即清楚的 - 为什么与零比较？

if ("Hello".CompareTo("World") == 0)

.CompareTo 不仅仅是为了检查相等性而设计的（为此您有 == ） - 它比较两个字符串。您可以使用 .CompareTo 来确定一个字符串是否比另一个字符串“更大”。您可以检查相等性，因为它对于相等的字符串产生零，但这不是它的概念。

因此，有不同的方法和接口来检查相等性（IEquatable、运算符 ==）和比较（IComparable），

这里 Linq 的行为与常规 C# 没有什么不同。

In my opinion, you should always use the clearest way, which is using ==!

This can be understood directly: When "Hello" equals "World" then do something.

if ("Hello" == "World")
    // ...

Internally, String::Equals is invoked which exists explicitly for this purpose - Comparing two strings for equality. (This has nothing to do with pointers and references etc.)

This here isn't immediately clear - Why compare to zero?

if ("Hello".CompareTo("World") == 0)

.CompareTo isn't designed just for checking equality (you have == for this) - It compares two strings. You use .CompareTo in sorts to determine wheter one string is "greater" than another. You can check for equality because it yield zero for equal strings, but that's not what it's concepted for.

Hence there are different methods and interfaces for checking equality (IEquatable, operator ==) and comparing (IComparable)

Linq doesn't behave different than regular C# here.

回复收藏 0 原文