LINQ contém maiúsculas e minúsculas

Este código faz distinção entre maiúsculas e minúsculas, como torná-lo sem distinção entre maiúsculas e minúsculas?

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

Supondo que estamos trabalhando com strings aqui, aqui está outra solução "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())

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

.Where(a => a.Field.Contains("hello")) torna-se Field LIKE '%hello%'. O LIKEoperador não diferencia maiúsculas de minúsculas por padrão, mas isso pode ser alterado alterando o agrupamento da coluna .

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

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

No entanto, ele não parece oferecer suporte a um método que é avaliado LIKEem LINQ to SQL e em uma comparação sem distinção entre maiúsculas e minúsculas no .NET, tornando impossível executar Contains () sem diferenciação de maiúsculas e minúsculas de maneira consistente.

A resposta aceita aqui não menciona o fato de que, se você tiver uma sequência nula, ToLower () lançará uma exceção. A maneira mais segura seria fazer:

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

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 esta (também verificando se é nulo):

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

IndexOf funciona melhor neste caso

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

Você pode usar string.Compare

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

se você quiser apenas verificar o conteúdo, use "Qualquer"

  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 apenas faça o trabalho para mim:

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

Honestamente, isso não precisa ser difícil. Pode parecer que no início, mas não é. Aqui está uma consulta linq simples em C # que faz exatamente como solicitado.

No meu exemplo, estou trabalhando com uma lista de pessoas que têm uma propriedade chamada FirstName.

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

Isso pesquisará o banco de dados na pesquisa em minúsculas, mas retornará resultados completos.

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