Recherche de liste sensible à la casse

Question

J'ai une liste testList qui contient un tas de chaînes de caractères. Je voudrais ajouter une nouvelle chaîne dans le fichier testList seulement s'il n'existe pas déjà dans la liste. Par conséquent, je dois effectuer une recherche insensible à la casse dans la liste et la rendre efficace. Je ne peux pas utiliser Contains parce que ça ne tient pas compte de l'enveloppe. Je ne veux pas non plus utiliser ToUpper/ToLower pour des raisons de performance. Je suis tombé sur cette méthode, qui fonctionne :

    if(testList.FindAll(x => x.IndexOf(keyword, 
                       StringComparison.OrdinalIgnoreCase) >= 0).Count > 0)
       Console.WriteLine("Found in list");

Cela fonctionne, mais cela correspond aussi à des mots partiels. Si la liste contient "chèvre", je ne peux pas ajouter "avoine" car il prétend que "avoine" est déjà dans la liste. Existe-t-il un moyen d'effectuer une recherche efficace dans les listes sans tenir compte de la casse, les mots devant correspondre exactement ? Merci.

Answer 1

Je sais que c'est un vieux message, mais au cas où quelqu'un d'autre chercherait, vous peut utiliser Contains en fournissant le comparateur d'égalité de chaînes de caractères insensible à la casse, comme suit :

using System.Linq;

// ...

if (testList.Contains(keyword, StringComparer.OrdinalIgnoreCase))
{
    Console.WriteLine("Keyword Exists");
}

Cette fonction est disponible depuis la version 2.0 de .net, selon le site Web de la Commission européenne. msdn .

Answer 2

Au lieu de String.IndexOf, utilisez String.Equals pour s'assurer que vous n'avez pas de correspondance partielle. N'utilisez pas non plus FindAll, qui passe en revue tous les éléments. FindIndex (il s'arrête sur le premier qu'il touche).

if(testList.FindIndex(x => x.Equals(keyword,  
    StringComparison.OrdinalIgnoreCase) ) != -1) 
    Console.WriteLine("Found in list"); 

Vous pouvez aussi utiliser des méthodes LINQ (qui s'arrêtent également à la première qu'elles rencontrent).

if( testList.Any( s => s.Equals(keyword, StringComparison.OrdinalIgnoreCase) ) )
    Console.WriteLine("found in list");

Answer 3

Sur la base de la réponse d'Adam Sills ci-dessus - voici une méthode d'extension propre pour les conteneurs... :)

///----------------------------------------------------------------------
/// <summary>
/// Determines whether the specified list contains the matching string value
/// </summary>
/// <param name="list">The list.</param>
/// <param name="value">The value to match.</param>
/// <param name="ignoreCase">if set to <c>true</c> the case is ignored.</param>
/// <returns>
///   <c>true</c> if the specified list contais the matching string; otherwise, <c>false</c>.
/// </returns>
///----------------------------------------------------------------------
public static bool Contains(this List<string> list, string value, bool ignoreCase = false)
{
    return ignoreCase ?
        list.Any(s => s.Equals(value, StringComparison.OrdinalIgnoreCase)) :
        list.Contains(value);
}

Answer 4

Vous vérifiez si le résultat d'IndexOf est supérieur ou égal à 0, c'est-à-dire si la correspondance commence. partout dans la chaîne. Essayez de vérifier si c'est égal à 0 :

if (testList.FindAll(x => x.IndexOf(keyword, 
                   StringComparison.OrdinalIgnoreCase) >= 0).Count > 0)
   Console.WriteLine("Found in list");

Maintenant, "chèvre" et "avoine" ne correspondront pas, mais "chèvre" et "goa" le feront. Pour éviter cela, vous pouvez comparer la longueur des deux chaînes de caractères.

Pour éviter toute cette complication, vous pouvez utiliser un dictionnaire au lieu d'une liste. La clé serait la chaîne en minuscules, et la valeur serait la vraie chaîne. De cette manière, les performances ne sont pas affectées car vous n'avez pas à utiliser ToLower pour chaque comparaison, mais vous pouvez toujours utiliser Contains .

Answer 5

J'ai eu un problème similaire, j'avais besoin de l'index de l'élément mais il devait être insensible à la casse, j'ai cherché sur le web pendant quelques minutes et je n'ai rien trouvé, donc j'ai juste écrit une petite méthode pour y arriver, voici ce que j'ai fait :

private static int getCaseInvariantIndex(List<string> ItemsList, string searchItem)
{
    List<string> lowercaselist = new List<string>();

    foreach (string item in ItemsList)
    {
        lowercaselist.Add(item.ToLower());
    }

    return lowercaselist.IndexOf(searchItem.ToLower());
}

Ajoutez ce code au même fichier, et appelez-le comme ceci :

int index = getCaseInvariantIndexFromList(ListOfItems, itemToFind);

J'espère que cela vous aidera, bonne chance !