query - linq c# tutorial español

LINQ contiene caso insensible

Question

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

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

Answer 1

IndexOf funciona mejor en este caso

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

Answer 2

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())

Answer 3

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)

Answer 4

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.

Answer 5

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

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

Answer 6

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;

Answer 7

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

Answer 8

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

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

Answer 9

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

Answer 10

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