LINQ enthält Groß- und Kleinschreibung

Bei diesem Code wird zwischen Groß- und Kleinschreibung unterschieden. Wie wird die Groß- und Kleinschreibung beachtet?

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

Angenommen, wir arbeiten hier mit Strings, dann ist hier eine andere "elegante" Lösung 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())

Wenn die LINQ-Abfrage im Datenbankkontext ausgeführt Contains()wird, wird dem LIKEOperator ein Aufruf von zugeordnet :

.Where(a => a.Field.Contains("hello")) wird Field LIKE '%hello%'. Der LIKEOperator unterscheidet standardmäßig nicht zwischen Groß- und Kleinschreibung. Dies kann jedoch durch Ändern der Sortierung der Spalte geändert werden .

Wenn die LINQ-Abfrage im .NET-Kontext ausgeführt wird, können Sie IndexOf () verwenden , diese Methode wird jedoch in LINQ to SQL nicht unterstützt.

LINQ to SQL unterstützt keine Methoden , die CultureInfo als Parameter verwenden, wahrscheinlich weil nicht garantiert werden kann, dass der SQL Server Kulturen wie .NET behandelt. Das ist nicht ganz richtig, denn es tut Unterstützung StartsWith(string, StringComparison).

Es scheint jedoch keine Methode zu unterstützen, die LIKEin LINQ zu SQL und zu einem Vergleich ohne Berücksichtigung der Groß- und Kleinschreibung in .NET ausgewertet wird , sodass es unmöglich ist, Contains () ohne Berücksichtigung der Groß- und Kleinschreibung auf konsistente Weise auszuführen.

In der hier akzeptierten Antwort wird nicht erwähnt, dass ToLower () eine Ausnahme auslöst, wenn Sie eine Nullzeichenfolge haben. Der sicherere Weg wäre:

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

Mit C # 6.0 (das Ausdrucksfunktionen und die Weitergabe von Nullen ermöglicht) kann LINQ to Objects in einer einzigen Zeile wie dieser ausgeführt werden (auch auf Null prüfen):

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

IndexOf funktioniert in diesem Fall am besten

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

Sie können string.Compare verwenden

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

Wenn Sie nur die enthaltenen Inhalte überprüfen möchten, verwenden Sie "Beliebig".

  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 erledigt einfach den Job für mich:

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

Ehrlich gesagt muss das nicht schwierig sein. Es mag so scheinen, als ob es am Anfang wäre, aber es ist nicht so. Hier ist eine einfache Linq-Abfrage in C #, die genau den Anforderungen entspricht.

In meinem Beispiel arbeite ich gegen eine Liste von Personen mit einer Eigenschaft namens Vorname.

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

Dadurch wird die Datenbank bei der Suche in Kleinbuchstaben durchsucht, es werden jedoch vollständige Ergebnisse in Groß- und Kleinschreibung zurückgegeben.

Verwenden Sie die String.Equals- Methode

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