LINQ contiene mayúsculas y minúsculas

Este código distingue entre mayúsculas y minúsculas, ¿cómo hacerlo?

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

Asumiendo que estamos trabajando con cadenas aquí, aquí hay otra solución "elegante" usando 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 consulta LINQ se ejecuta en el contexto de la base de datos, Contains()se asigna una llamada al LIKEoperador:

.Where(a => a.Field.Contains("hello")) se convierte Field LIKE '%hello%'. El LIKEoperador no distingue entre mayúsculas y minúsculas de forma predeterminada, pero eso se puede cambiar cambiando la clasificació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 toman un CultureInfo como parámetro, probablemente porque no puede garantizar que el servidor SQL maneje cultivos de la misma manera que .NET. Esto no es completamente cierto, porque sí es compatible StartsWith(string, StringComparison).

Sin embargo, no parece admitir un método que se evalúe LIKEen LINQ to SQL y en una comparación de mayúsculas y minúsculas en .NET, por lo que es imposible hacer Contains () insensible a mayúsculas y minúsculas de manera consistente.

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

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

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

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

IndexOf funciona mejor en este caso

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

Puedes usar string.Compare

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

si solo desea verificar los contenidos, use "Cualquiera"

  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 solo hace el trabajo por mí:

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

Honestamente, esto no tiene por qué ser difícil. Puede parecer que al principio, pero no lo es. Aquí hay una consulta simple de linq en C # que hace exactamente lo solicitado.

En mi ejemplo, estoy trabajando contra una lista de personas que tienen una propiedad llamada FirstName.

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

Esto buscará en la base de datos en la búsqueda de minúsculas pero devolverá los resultados completos de las mayúsculas.

Utilice el método String.Equals

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