LINQ contiene caso insensible

Este código distingue entre mayúsculas y minúsculas, ¿cómo hacer que no distinga entre mayúsculas y minúsculas?

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

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

Si la consulta LINQ se ejecuta en el contexto de la base de datos, una llamada a Contains() se asigna al operador LIKE :

.Where(a => a.Field.Contains("hello")) convierte en Field LIKE '%hello%' . El operador LIKE distingue entre mayúsculas y minúsculas de forma predeterminada, pero eso se puede cambiar cambiando la intercalación de la columna .

Si la consulta LINQ se ejecuta en contexto .NET, puede usar IndexOf () , pero ese método no es compatible con LINQ to SQL.

LINQ to SQL no admite métodos que tengan un CultureInfo como parámetro, probablemente porque no puede garantizar que el servidor SQL maneje culturas de la misma manera que .NET. Esto no es completamente cierto, porque admite StartsWith(string, StringComparison) .

Sin embargo, no parece ser compatible con un método que evalúa LIKE en LINQ to SQL, y con una comparación insensible a mayúsculas y minúsculas en .NET, lo que hace que sea imposible hacer Conins () insensible a mayúsculas / minúsculas de forma consistente.

Suponiendo que estamos trabajando con cadenas aquí, aquí hay otra solución “elegante” que usa IndexOf() .

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

La respuesta aceptada aquí no menciona el hecho de que si tiene una cadena nula, ToLower () lanzará una excepción. La manera más segura sería hacer:

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

Usando C # 6.0 (que permite funciones de cuerpo de expresión y propagación nula), para LINQ to Objects, se puede hacer en una sola línea como esta (también verificando null):

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

Puede usar una cuerda.Compare

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

si solo quieres marcar contiene, utiliza “Cualquiera”

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

IndexOf funciona mejor en este caso

 return this .ObjectContext .FACILITY_ITEM .Where(fi => fi.DESCRIPTION.IndexOf(description, StringComparison.OrdinalIgnoreCase)>=0); 
 public static bool Contains(this string input, string findMe, StringComparison comparisonType) { return String.IsNullOrWhiteSpace(input) ? false : input.IndexOf(findMe, comparisonType) > -1; } 

Utilice el método Enumerable.Contains (IEnumerable, TSource, IEqualityComparer) , utilizando uno de los comparadores StringComparer .___ IgnoreCase (ya sea Ordinal, InvariantCulture o CurrentCulture).

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

Use el método String.Equals

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