Comment puis-je faire une comparaison de chaînes insensible à la casse?

Comment puis-je rendre la ligne ci-dessous insensible à la casse?

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

Plus tôt dans la journée, j'ai reçu des conseils qui m'ont suggéré d'utiliser:

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

le problème est que je ne peux pas faire fonctionner cela, j'ai essayé la ligne ci-dessous, cela compile mais renvoie les mauvais résultats, il renvoie les utilisateurs inscrits comme non inscrits et les utilisateurs non inscrits comme inscrits.

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

Quelqu'un peut-il signaler le problème?

Ce n'est pas la meilleure pratique dans .NET Framework (4 & +) pour vérifier l'égalité

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

Utilisez plutôt ce qui suit

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

MSDN recommande:

• Utilisez une surcharge de la méthode String.Equals pour tester si deux chaînes sont égales.
• Utilisez les méthodes String.Compare et String.CompareTo pour trier les chaînes, pas pour vérifier l'égalité .

Vous devez utiliser une String.Comparefonction statique comme suit

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

Veuillez utiliser ceci pour la comparaison:

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

D'autres réponses sont totalement valables ici, mais d'une manière ou d'une autre, cela prend un certain temps pour taper StringComparison.OrdinalIgnoreCaseet également utiliser String.Compare.

J'ai codé une méthode d'extension de chaîne simple, où vous pouvez spécifier si la comparaison est sensible à la casse ou insensée à la valeur booléenne, en attachant un extrait de code entier ici:

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;
    }
}

Après que toute la comparaison se raccourcisse de 10 caractères environ - comparez:

Avant d'utiliser l'extension String:

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

Après avoir utilisé l'extension String:

testFilename.CompareTo(testToStart, true)

Vous pouvez (bien que controversé) étendre System.Stringpour fournir une méthode d'extension de comparaison insensible à la casse:

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

et utiliser comme tel:

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

C # vous permet de créer des méthodes d'extension qui peuvent servir de syntaxe au sucre dans votre projet, je dirais plutôt utile.

Ce n'est pas la réponse et je sais que cette question est ancienne et résolue, je voulais juste ajouter ces bits.

Je pense que vous trouverez plus d'informations dans ce lien:

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

Utilisez la méthode Compare static sur la classe String pour comparer les deux chaînes. Le fait que la comparaison soit insensible à la casse est déterminé par le troisième paramètre de l'une de ses surcharges. Par exemple:

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

La valeur caseSensitiveResult est -1 (indiquant que lowerCase est "inférieur à" upperCase) et le caseInsensitiveResult est zéro (indiquant que lowerCase "est égal" à upperCase).

Que diriez-vous d'utiliser à la StringComparison.CurrentCultureIgnoreCaseplace?

Je voudrais écrire une méthode d'extension pour EqualsIgnoreCase

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

vous pouvez toujours utiliser des fonctions: .ToLower (); .ToUpper ();

convertissez vos chaînes puis comparez-les ...

Bonne chance