LINQ contiene case insensitive

Questo codice fa distinzione tra maiuscole e minuscole, come renderlo maiuscole e minuscole?

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

Supponendo che stiamo lavorando con le stringhe qui, ecco un'altra soluzione "elegante" che utilizza 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 la query LINQ viene eseguita nel contesto del database, una chiamata a Contains()viene mappata LIKEall'operatore:

.Where(a => a.Field.Contains("hello")) diventa Field LIKE '%hello%'. L' LIKEoperatore non distingue tra maiuscole e minuscole per impostazione predefinita, ma può essere modificato modificando le regole di confronto della colonna .

Se la query LINQ viene eseguita nel contesto .NET, è possibile utilizzare IndexOf () , ma tale metodo non è supportato in LINQ to SQL.

LINQ to SQL non supporta metodi che accettano un CultureInfo come parametro, probabilmente perché non può garantire che il server SQL gestisca le colture allo stesso modo di .NET. Questo non è completamente vero, perché fa il supporto StartsWith(string, StringComparison).

Tuttavia, non sembra supportare un metodo che valuta LIKEin LINQ to SQL e un confronto senza distinzione tra maiuscole e minuscole in .NET, rendendo impossibile eseguire Contains () senza distinzione tra maiuscole e minuscole in modo coerente.

La risposta accettata qui non menziona il fatto che se hai una stringa nulla ToLower () genererà un'eccezione. Il modo più sicuro sarebbe quello di fare:

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

Utilizzando C # 6.0 (che consente le funzioni di espressione e la propagazione nulla), per LINQ to Objects, può essere fatto in una sola riga come questa (controllando anche la presenza di null):

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

IndexOf funziona meglio in questo caso

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

Puoi usare string.Compare

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

se vuoi solo controllare contiene quindi usa "Qualsiasi"

  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 fa solo il lavoro per me:

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

Onestamente, questo non deve essere difficile. Può sembrare che all'inizio, ma non lo è. Ecco una semplice query linq in C # che fa esattamente come richiesto.

Nel mio esempio, sto lavorando su un elenco di persone che hanno una proprietà chiamata FirstName.

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

Ciò cercherà nel database con la ricerca in minuscolo ma restituirà i risultati in maiuscolo.

Usa il metodo String.Equals

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