[c#] Различия в методах сравнения строк в C #



Answers

Из MSDN:

«Метод CompareTo был разработан в первую очередь для использования в сортировке или в алфавитном порядке. Он не должен использоваться, если основной целью вызова метода является определение того, эквивалентны две строки. Чтобы определить, эквивалентны две строки, вызовите метод Equals. "

Они предлагают использовать .Equals вместо .CompareTo если смотреть только на равенство. Я не уверен, есть ли разница между .Equals и == для класса string . Иногда я буду использовать .Equals или Object.ReferenceEquals вместо == для своих собственных классов, если кто-то появится позже и переопределит оператор == этого класса.

Question

Сравнение строки в C # довольно просто. На самом деле есть несколько способов сделать это. Я перечислил некоторые в блоке ниже. Что мне интересно узнать о различиях между ними и о том, когда нужно использовать других? Следует ли избегать любой ценой? Больше ли я не перечислял?

string testString = "Test";
string anotherString = "Another";

if (testString.CompareTo(anotherString) == 0) {}
if (testString.Equals(anotherString)) {}
if (testString == anotherString) {}

(Примечание: я ищу равенство в этом примере, не меньше или больше, но не стесняйтесь прокомментировать это)




Как сказал Ed , CompareTo используется для сортировки.

Однако есть разница между .Equals и ==.

== разрешает по существу следующий код:

if(object.ReferenceEquals(left, null) && 
   object.ReferenceEquals(right, null))
    return true;
if(object.ReferenceEquals(left, null))
    return right.Equals(left);
return left.Equals(right);

Простая причина заключается в следующем:

string a = null;
string b = "foo";

bool equal = a.Equals(b);

И следующее не будет:

string a = null;
string b = "foo";

bool equal = a == b;



с .Equals, вы также получаете опции StringComparison. очень удобно для игнорирования случая и других вещей.

btw, это будет оцениваться как false

string a = "myString";
string b = "myString";

return a==b

Поскольку == сравнивает значения a и b (которые являются указателями), это будет оценивать только true, если указатели указывают на один и тот же объект в памяти. .Equals разыгрывает указатели и сравнивает значения, хранящиеся в указателях. a.Equals (b) будет здесь.

и если вы измените b на:

b = "MYSTRING";

то a.Equals (b) является ложным, но

a.Equals(b, StringComparison.OrdinalIgnoreCase) 

было бы правдой

a.CompareTo (b) вызывает функцию CompareTo в строке, которая сравнивает значения в указателях и возвращает <0, если значение, хранящееся в a, меньше значения, сохраненного в b, возвращает 0, если a.Equals (b) истинно, и > 0 в противном случае. Тем не менее, это чувствительно к регистру, я думаю, что есть возможности для CompareTo игнорировать случай и т. Д., Но у меня нет времени смотреть сейчас. Как уже указывали другие, это будет сделано для сортировки. Сопоставление для равенства таким образом приведет к ненужным накладным расходам.

Я уверен, что я оставляю вещи, но я думаю, что для этого достаточно информации, чтобы начать экспериментировать, если вам нужно больше деталей.




Одна большая разница в примечании: .Equals () генерирует исключение, если первая строка имеет значение null, а == === =============

       string s = null;
        string a = "a";
        //Throws {"Object reference not set to an instance of an object."}
        if (s.Equals(a))
            Console.WriteLine("s is equal to a");
        //no Exception
        if(s==a)
            Console.WriteLine("s is equal to a");



CompareTo сравнивает строку со строковым объектом и возвращает значение int. Если значение равно 0, значит, строки равны.

string country = "southindia";
object ob1 = country.Clone();
Console.WriteLine( country.CompareTo(ob1));

string country = "southindia";
string cou = "insia";
int n = country.CompareTo(cou);
Console.WriteLine( n );



Не то, что производительность обычно имеет значение в 99% случаев, когда вам нужно это делать, но если вам нужно было сделать это в цикле несколько миллионов раз, я бы настоятельно предложил использовать .Equals или ==, потому что, как только он найдет символ который не соответствует ему, выдает все это как ложное, но если вы используете CompareTo, ему придется выяснить, какой символ меньше, чем другой, что приводит к немного худшему времени исполнения.

Если ваше приложение будет работать в разных странах, я бы рекомендовал вам взглянуть на последствия CultureInfo и, возможно, использовать .Equals. Поскольку я действительно пишу приложения для США (и не волнует, если кто-то не работает должным образом), я всегда просто использую ==.






Links