LINQ contient insensible à la casse

Ce code est sensible à la casse, comment le rendre insensible à la casse?

public IQueryable<FACILITY_ITEM> GetFacilityItemRootByDescription(string description)
{
    return this.ObjectContext.FACILITY_ITEM.Where(fi => fi.DESCRIPTION.Contains(description));
}

En supposant que nous travaillons avec des chaînes ici, voici une autre solution "élégante" utilisant IndexOf().

public IQueryable<FACILITY_ITEM> GetFacilityItemRootByDescription(string description)
{
    return this.ObjectContext.FACILITY_ITEM
        .Where(fi => fi.DESCRIPTION
                       .IndexOf(description, StringComparison.OrdinalIgnoreCase) != -1);
}

fi => fi.DESCRIPTION.ToLower().Contains(description.ToLower())

Si la requête LINQ est exécutée dans le contexte de la base de données, un appel à Contains()est mappé à l' LIKEopérateur:

.Where(a => a.Field.Contains("hello")) devient Field LIKE '%hello%'. L' LIKEopérateur est insensible à la casse par défaut, mais cela peut être modifié en modifiant le classement de la colonne .

Si la requête LINQ est exécutée dans un contexte .NET, vous pouvez utiliser IndexOf () , mais cette méthode n'est pas prise en charge dans LINQ to SQL.

LINQ to SQL ne prend pas en charge les méthodes qui prennent un CultureInfo comme paramètre, probablement parce qu'il ne peut pas garantir que le serveur SQL gère les cultures de la même manière que .NET. Ce n'est pas tout à fait vrai, car il prend en chargeStartsWith(string, StringComparison) .

Cependant, il ne semble pas prendre en charge une méthode qui évalue LIKEdans LINQ to SQL, et à une comparaison insensible à la casse dans .NET, ce qui rend impossible de faire Contains () insensible à la casse de manière cohérente.

La réponse acceptée ici ne mentionne pas le fait que si vous avez une chaîne nulle, ToLower () lèvera une exception. La manière la plus sûre serait de faire:

fi => (fi.DESCRIPTION ?? string.Empty).ToLower().Contains((description ?? string.Empty).ToLower())

En utilisant C # 6.0 (qui autorise les fonctions de corps d'expression et la propagation nulle), pour LINQ to Objects, cela peut être fait en une seule ligne comme celle-ci (en vérifiant également la valeur null):

public static bool ContainsInsensitive(this string str, string value) => str?.IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0;

IndexOf fonctionne mieux dans ce cas

return this
   .ObjectContext
   .FACILITY_ITEM
   .Where(fi => fi.DESCRIPTION.IndexOf(description, StringComparison.OrdinalIgnoreCase)>=0);

Vous pouvez utiliser une chaîne.

    lst.Where(x => string.Compare(x,"valueToCompare",StringComparison.InvariantCultureIgnoreCase)==0);

si vous voulez juste vérifier contient, utilisez "Any"

  lst.Any(x => string.Compare(x,"valueToCompare",StringComparison.InvariantCultureIgnoreCase)==0)

public static bool Contains(this string input, string findMe, StringComparison comparisonType)
{
    return String.IsNullOrWhiteSpace(input) ? false : input.IndexOf(findMe, comparisonType) > -1;
}

StringComparison.InvariantCultureIgnoreCase fait juste le travail pour moi:

.Where(fi => fi.DESCRIPTION.Contains(description, StringComparison.InvariantCultureIgnoreCase));

Honnêtement, cela n'a pas besoin d'être difficile. Cela peut sembler au début, mais ce n'est pas le cas. Voici une simple requête linq en C # qui fait exactement comme demandé.

Dans mon exemple, je travaille sur une liste de personnes qui ont une propriété appelée FirstName.

var results = ClientsRepository().Where(c => c.FirstName.ToLower().Contains(searchText.ToLower())).ToList();

Cela recherchera dans la base de données une recherche en minuscules mais retournera des résultats complets.

Utilisez la méthode String.Equals

public IQueryable<FACILITY_ITEM> GetFacilityItemRootByDescription(string description)
{
    return this.ObjectContext.FACILITY_ITEM
           .Where(fi => fi.DESCRIPTION
           .Equals(description, StringComparison.OrdinalIgnoreCase));
}