LINQ Chứa trường hợp không nhạy cảm

Mã này là trường hợp nhạy cảm, làm thế nào để làm cho nó không nhạy cảm?

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

Giả sử chúng ta đang làm việc với các chuỗi ở đây, đây là một giải pháp "thanh lịch" khác bằng cách sử dụng 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())

Nếu truy vấn LINQ được thực thi trong ngữ cảnh cơ sở dữ liệu, một lệnh gọi Contains()được ánh xạ tới LIKEtoán tử:

.Where(a => a.Field.Contains("hello")) trở thành Field LIKE '%hello%'. Các LIKEnhà điều hành là trường hợp nhạy cảm theo mặc định, nhưng có thể được thay đổi bằng cách thay đổi collation của cột .

Nếu truy vấn LINQ được thực thi trong ngữ cảnh .NET, bạn có thể sử dụng IndexOf () , nhưng phương thức đó không được hỗ trợ trong LINQ to SQL.

LINQ to SQL không hỗ trợ các phương thức lấy tham số CultureInfo làm tham số, có lẽ vì nó không thể đảm bảo rằng máy chủ SQL xử lý các nền văn hóa giống như .NET. Đây không phải là hoàn toàn đúng, bởi vì nó không hỗ trợ StartsWith(string, StringComparison).

Tuy nhiên, nó dường như không hỗ trợ một phương thức đánh giá LIKEtrong LINQ to SQL và so sánh trường hợp không nhạy cảm trong .NET, khiến cho không thể thực hiện các trường hợp không phân biệt chữ hoa chữ thường () theo cách nhất quán.

Câu trả lời được chấp nhận ở đây không đề cập đến một thực tế là nếu bạn có chuỗi null ToLower () sẽ đưa ra một ngoại lệ. Cách an toàn hơn sẽ là:

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

Sử dụng C # 6.0 (cho phép các hàm thân biểu thức và lan truyền null), đối với LINQ đến các Đối tượng, nó có thể được thực hiện trong một dòng như thế này (cũng kiểm tra null):

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

IndexOf hoạt động tốt nhất trong trường hợp này

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

Bạn có thể sử dụng chuỗi.

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

nếu bạn chỉ muốn kiểm tra có chứa thì hãy sử dụng "Bất kỳ"

  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.InvariantCARMIgnoreCase chỉ làm công việc cho tôi:

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

Thành thật mà nói, điều này không cần phải khó khăn. Có vẻ như trên khởi phát, nhưng nó không phải là. Đây là một truy vấn linq đơn giản trong C # thực hiện chính xác như yêu cầu.

Trong ví dụ của tôi, tôi đang làm việc với một danh sách những người có một tài sản được gọi là FirstName.

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

Điều này sẽ tìm kiếm cơ sở dữ liệu về tìm kiếm chữ thường nhưng trả về kết quả trường hợp đầy đủ.

Sử dụng phương thức String.Equals

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