Có một trường hợp C # không nhạy cảm toán tử bằng?

Tôi biết rằng sau đây là trường hợp nhạy cảm:

if (StringA == StringB) {

Vì vậy, có một toán tử sẽ so sánh hai chuỗi một cách không nhạy cảm?

Thử cái này:

string.Equals(a, b, StringComparison.CurrentCultureIgnoreCase);

Cách tốt nhất để so sánh 2 chuỗi bỏ qua trường hợp của các chữ cái là sử dụng phương thức tĩnh String.Equals chỉ định so sánh chuỗi trường hợp bỏ qua thứ tự. Đây cũng là cách nhanh nhất, nhanh hơn nhiều so với chuyển đổi chuỗi thành chữ thường hoặc chữ hoa và so sánh chúng sau đó.

Tôi đã thử nghiệm hiệu suất của cả hai phương pháp và so sánh chuỗi trường hợp bỏ qua thứ tự nhanh hơn 9 lần ! Nó cũng đáng tin cậy hơn so với chuyển đổi chuỗi thành chữ thường hoặc chữ hoa (kiểm tra vấn đề i của Thổ Nhĩ Kỳ). Vì vậy, luôn luôn sử dụng phương thức String.Equals để so sánh các chuỗi cho đẳng thức:

String.Equals(string1, string2, StringComparison.OrdinalIgnoreCase);

Nếu bạn muốn thực hiện so sánh chuỗi văn hóa cụ thể, bạn có thể sử dụng mã sau:

String.Equals(string1, string2, StringComparison.CurrentCultureIgnoreCase);

Xin lưu ý rằng ví dụ thứ hai sử dụng logic so sánh chuỗi của văn hóa hiện tại, làm cho nó chậm hơn so với so sánh "trường hợp bỏ qua thứ tự" trong ví dụ đầu tiên, vì vậy nếu bạn không cần logic so sánh chuỗi cụ thể về văn hóa và bạn sau khi thực hiện tối đa, sử dụng so sánh "trường hợp bỏ qua thứ tự".

Để biết thêm thông tin, đọc toàn bộ câu chuyện trên blog của tôi .

Có một số thuộc tính trên StringComparerlớp tĩnh trả về các so sánh cho bất kỳ loại phân biệt chữ hoa chữ thường nào bạn muốn:

StringComparer Tính chất

Chẳng hạn, bạn có thể gọi

StringComparer.CurrentCultureIgnoreCase.Equals(string1, string2)

hoặc là

StringComparer.CurrentCultureIgnoreCase.Compare(string1, string2)

Nó sạch hơn một chút so với string.Equalshoặc string.Comparequá tải cần StringComparisontranh luận.

System.Collections.CaseInsensitiveComparer

hoặc là

System.StringComparer.OrdinalIgnoreCase

string.Equals(StringA, StringB, StringComparison.CurrentCultureIgnoreCase);

hoặc là

if (StringA.Equals(StringB, StringComparison.CurrentCultureIgnoreCase)) {

nhưng bạn cần chắc chắn rằng StringA không phải là null. Vì vậy, có lẽ tốt hơn sử dụng tu:

string.Equals(StringA , StringB, StringComparison.CurrentCultureIgnoreCase);

như John đề nghị

EDIT: đã sửa lỗi

Bạn có thể dùng

if (stringA.equals(StringB, StringComparison.CurrentCultureIgnoreCase))

Nhà điều hành? KHÔNG, nhưng tôi nghĩ bạn có thể thay đổi văn hóa của mình để so sánh chuỗi không phân biệt chữ hoa chữ thường.

// you'll want to change this...
System.Threading.Thread.CurrentThread.CurrentCulture
// and you'll want to custimize this
System.Globalization.CultureInfo.CompareInfo

Tôi tự tin rằng nó sẽ thay đổi cách các chuỗi được so sánh bởi toán tử bằng.

Đây là một ý tưởng để đơn giản hóa cú pháp:

public class IgnoreCase
{
    private readonly string _value;

    public IgnoreCase(string s)
    {
        _value = s;
    }

    protected bool Equals(IgnoreCase other)
    {
        return this == other;
    }

    public override bool Equals(object obj)
    {
        return obj != null &&
               (ReferenceEquals(this, obj) || (obj.GetType() == GetType() && this == (IgnoreCase) obj));
    }

    public override int GetHashCode()
    {
        return _value?.GetHashCode() ?? 0;
    }

    public static bool operator ==(IgnoreCase a, IgnoreCase b)
    {
        return string.Equals(a, b, StringComparison.OrdinalIgnoreCase);
    }

    public static bool operator !=(IgnoreCase a, IgnoreCase b)
    {
        return !(a == b);
    }

    public static implicit operator string(IgnoreCase s)
    {
        return s._value;
    }

    public static implicit operator IgnoreCase(string s)
    {
        return new IgnoreCase(s);
    }
}

Có thể sử dụng như:

Console.WriteLine((IgnoreCase) "a" == "b"); // false
Console.WriteLine((IgnoreCase) "abc" == "abC"); // true
Console.WriteLine((IgnoreCase) "Abc" == "aBc"); // true
Console.WriteLine((IgnoreCase) "ABC" == "ABC"); // true

Tôi đã quá quen với việc gõ vào cuối các phương thức so sánh này: , StringComparison.

Vì vậy, tôi đã thực hiện một phần mở rộng.

namespace System
{   public static class StringExtension
    {
        public static bool Equals(this string thisString, string compareString,
             StringComparison stringComparison)
        {
            return string.Equals(thisString, compareString, stringComparison);
        }
    }
}

Chỉ cần lưu ý rằng bạn sẽ cần kiểm tra null thisStringtrước khi gọi máy lẻ.

string.Compare(string1, string2, true)

if (StringA.ToUpperInvariant() == StringB.ToUpperInvariant()) {

Mọi người báo cáo ToUpperInvariant () nhanh hơn ToLowerInvariant ().

Những câu trả lời khác hoàn toàn hợp lệ ở đây, nhưng bằng cách nào đó, bạn phải mất một thời gian để nhập StringComparison.OrdinalIgnoreCasevà sử dụng String.Compare.

Tôi đã mã hóa phương thức mở rộng Chuỗi đơn giản, trong đó bạn có thể chỉ định nếu so sánh là phân biệt chữ hoa chữ thường hay chữ hoa chữ thường với boolean - xem câu trả lời sau:

https://stackoverflow.com/a/49208128/2338477