c# sensitive LINQ contém maiúsculas e minúsculas




string compare c# case insensitive (8)

Esse código faz distinção entre maiúsculas e minúsculas, como torná-lo insensível a maiúsculas e minúsculas?

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

Você pode usar string.Compare

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

se você quiser apenas verificar contém, em seguida, use "Qualquer"

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

Use o método String.Equals

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

IndexOf funciona melhor neste caso

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

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

Se a consulta LINQ for executada no contexto do banco de dados, uma chamada para Contains() será mapeada para o operador LIKE :

.Where(a => a.Field.Contains("hello")) se torna Field LIKE '%hello%' . O operador LIKE é insensível a maiúsculas e minúsculas por padrão, mas isso pode ser alterado alterando o agrupamento da coluna .

Se a consulta LINQ é executada no contexto .NET, você pode usar IndexOf() , mas esse método não é suportado no LINQ to SQL.

O LINQ to SQL não suporta métodos que usam um CultureInfo como parâmetro, provavelmente porque ele não pode garantir que o SQL Server manipule culturas da mesma maneira que o .NET. Isso não é totalmente verdade, porque ele suporta StartsWith(string, StringComparison) .

No entanto, ele não parece oferecer suporte a um método que avalia como LIKE no LINQ to SQL e a uma comparação que não diferencia maiúsculas de minúsculas no .NET, tornando impossível fazer o Contains () insensível a maiúsculas e minúsculas de maneira consistente.


Usando o C # 6.0 (que permite funções corporais de expressão e propagação nula), para LINQ to Objects, isso pode ser feito em uma única linha como essa (também verificando null):

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

A resposta aceita aqui não menciona o fato de que, se você tiver uma string nula ToLower (), lançará uma exceção. O caminho mais seguro seria fazer:

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

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




linq