LINQ zawiera rozróżnianie wielkości liter

W tym kodzie rozróżniana jest wielkość liter, jak sprawić, by wielkość liter nie była rozróżniana?

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

Zakładając, że pracujemy tutaj ze stringami, oto kolejne „eleganckie” rozwiązanie wykorzystujące 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())

Jeśli zapytanie LINQ jest wykonywane w kontekście bazy danych, wywołanie Contains()jest mapowane na plikLIKE operatora:

.Where(a => a.Field.Contains("hello")) staje się Field LIKE '%hello%'. LIKEOperator nie uwzględnia wielkości liter domyślnie, ale które mogą być zmieniane przez zmianę sortowania kolumny .

Jeśli zapytanie LINQ jest wykonywane w kontekście .NET, możesz użyć IndexOf () , ale ta metoda nie jest obsługiwana w LINQ to SQL.

LINQ to SQL nie obsługuje metod, które przyjmują CultureInfo jako parametr, prawdopodobnie dlatego, że nie może zagwarantować, że serwer SQL obsługuje takie same kultury jak .NET. To nie jest do końca prawdą, ponieważ tak jest wsparciaStartsWith(string, StringComparison) .

Wydaje się jednak, że nie obsługuje ona metody, która LIKEw LINQ to SQL jest oceniana jako , ani do porównania niewrażliwego na wielkość liter w .NET, co uniemożliwia wykonanie Contains () bez uwzględniania wielkości liter w spójny sposób.

Przyjęta tutaj odpowiedź nie wspomina o fakcie, że jeśli masz pusty ciąg ToLower (), zgłosi wyjątek. Bezpieczniejszym sposobem byłoby:

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

Używając C # 6.0 (który umożliwia funkcje z wyrażeniami i propagację wartości null), dla LINQ to Objects, można to zrobić w jednym wierszu, takim jak ten (również sprawdzanie wartości null):

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

IndexOf działa najlepiej w tym przypadku

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

Możesz użyć string.Compare

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

jeśli chcesz tylko sprawdzić zawartość, użyj opcji „Dowolny”

  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 po prostu zrób to za mnie:

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

Szczerze mówiąc, to nie musi być trudne. Może się wydawać, że na początku, ale tak nie jest. Oto prosta kwerenda linq w C #, która działa dokładnie zgodnie z żądaniem.

W moim przykładzie pracuję przeciwko liście osób, które mają jedną właściwość o nazwie FirstName.

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

Spowoduje to przeszukanie bazy danych przy użyciu wyszukiwania małymi literami, ale zwróci pełne wyniki.

Użyj metody String.Equals

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