Jak mogę porównać ciąg znaków bez rozróżniania wielkości liter?

Jak mogę sprawić, aby wiersz poniżej nie rozróżniał wielkości liter?

drUser["Enrolled"] = 
      (enrolledUsers.FindIndex(x => x.Username == (string)drUser["Username"]) != -1);

Dostałem dzisiaj kilka porad, które sugerują, żebym użył:

x.Username.Equals((string)drUser["Username"], StringComparison.OrdinalIgnoreCase)));

Problem w tym, że nie mogę tego uruchomić. Wypróbowałem poniższy wiersz, który się kompiluje, ale zwraca nieprawidłowe wyniki, zwraca zarejestrowanych użytkowników jako niezarejestrowanych i niezarejestrowanych użytkowników jako zarejestrowanych.

drUser["Enrolled"] = 
      (enrolledUsers.FindIndex(x => x.Username.Equals((string)drUser["Username"], 
                                 StringComparison.OrdinalIgnoreCase)));

Czy ktoś może wskazać problem?

To nie jest najlepsza praktyka w .NET Framework (4 i +) do sprawdzania równości

String.Compare(x.Username, (string)drUser["Username"], 
                  StringComparison.OrdinalIgnoreCase) == 0

Zamiast tego użyj następujących

String.Equals(x.Username, (string)drUser["Username"], 
                   StringComparison.OrdinalIgnoreCase) 

MSDN zaleca:

• Użyj przeciążenia metody String.Equals, aby sprawdzić, czy dwa łańcuchy są równe.
• Użyj metod String.Compare i String.CompareTo do sortowania ciągów, a nie sprawdzania równości .

Powinieneś użyć String.Comparefunkcji statycznej jak poniżej

x => String.Compare (x.Username, (string)drUser["Username"],
                     StringComparison.OrdinalIgnoreCase) == 0

Użyj tego do porównania:

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

Inne odpowiedzi są tutaj całkowicie poprawne, ale jakoś zajmuje trochę czasu, aby pisać StringComparison.OrdinalIgnoreCasei używać String.Compare.

Kodowałem prostą metodę rozszerzenia Ciągu, w której można określić, czy w porównaniu rozróżniana jest wielkość liter, czy też nie ma sensu wielkość logiczna, dołączając tutaj cały fragment kodu:

using System;

/// <summary>
/// String helpers.
/// </summary>
public static class StringExtensions
{
    /// <summary>
    /// Compares two strings, set ignoreCase to true to ignore case comparison ('A' == 'a')
    /// </summary>
    public static bool CompareTo(this string strA, string strB, bool ignoreCase)
    {
        return String.Compare(strA, strB, ignoreCase) == 0;
    }
}

Po tym całe porównanie skraca się w przybliżeniu o 10 znaków - porównaj:

Przed użyciem rozszerzenia String:

String.Compare(testFilename, testToStart,true) != 0

Po użyciu rozszerzenia String:

testFilename.CompareTo(testToStart, true)

Można (choć kontrowersyjnie) rozszerzyć, System.Stringaby zapewnić metodę rozszerzenia porównania bez rozróżniania wielkości liter:

public static bool CIEquals(this String a, String b) {
    return a.Equals(b, StringComparison.CurrentCultureIgnoreCase);
}

i użyj jako takiego:

x.Username.CIEquals((string)drUser["Username"]);

C # pozwala tworzyć metody rozszerzeń, które mogą służyć jako narzędzie do tworzenia składni w twoim projekcie, co byłoby całkiem przydatne.

To nie jest odpowiedź i wiem, że to pytanie jest stare i rozwiązane, chciałem tylko dodać te bity.

Myślę, że znajdziesz więcej informacji w tym linku:

http://codeidol.com/community/dotnet/controlling-case-sensitivity-when-comparing-two-st/8873/

Użyj metody statycznej Porównaj w klasie String, aby porównać dwa ciągi. To, czy porównanie nie uwzględnia wielkości liter, zależy od trzeciego parametru jednego z jego przeciążeń. Na przykład:

string lowerCase = "abc";
string upperCase = "AbC";
int caseInsensitiveResult = string.Compare(lowerCase, upperCase,
  StringComparison.CurrentCultureIgnoreCase);
int caseSensitiveResult = string.Compare(lowerCase,
  StringComparison.CurrentCulture);

Wartość caseSensitiveResult wynosi -1 (wskazując, że lowerCase jest „mniejsza niż” upperCase), a caseInsensitiveResult ma wartość zero (wskazując, że lowerCase „równa się” upperCase).

A może StringComparison.CurrentCultureIgnoreCasezamiast tego użyć ?

Chciałbym napisać metodę rozszerzenia dla EqualsIgnoreCase

public static class StringExtensions
{
    public static bool? EqualsIgnoreCase(this string strA, string strB)
    {
        return strA?.Equals(strB, StringComparison.CurrentCultureIgnoreCase);
    }
}

zawsze możesz użyć funkcji: .ToLower (); .ToUpper ();

przekonwertować ciągi, a następnie porównać je ...

Powodzenia