Tìm kiếm danh sách không phân biệt chữ hoa chữ thường

Tôi có một danh sách testListchứa một chuỗi các chuỗi. Tôi muốn thêm một chuỗi mới vào testListchỉ khi nó không tồn tại trong danh sách. Do đó, tôi cần thực hiện tìm kiếm không phân biệt chữ hoa chữ thường và làm cho nó hiệu quả. Tôi không thể sử dụng Containsvì điều đó không tính đến vỏ. Tôi cũng không muốn sử dụng ToUpper/ToLowervì lý do hiệu suất. Tôi đã xem qua phương pháp này, hoạt động:

    if(testList.FindAll(x => x.IndexOf(keyword, 
                       StringComparison.OrdinalIgnoreCase) >= 0).Count > 0)
       Console.WriteLine("Found in list");

Điều này hoạt động, nhưng nó cũng phù hợp với một phần từ. Nếu danh sách chứa "dê", tôi không thể thêm "yến mạch" vì nó tuyên bố rằng "yến mạch" đã có trong danh sách. Có cách nào để tìm kiếm danh sách một cách hiệu quả trong trường hợp không nhạy cảm, trong đó các từ phải khớp chính xác? cảm ơn

Thay vì String.IndexOf, hãy sử dụng String.Equals để đảm bảo bạn không có kết quả khớp một phần. Ngoài ra, đừng sử dụng FindAll khi đi qua mọi phần tử, hãy sử dụng Find Index (nó dừng ở phần tử đầu tiên mà nó chạm).

if(testList.FindIndex(x => x.Equals(keyword,  
    StringComparison.OrdinalIgnoreCase) ) != -1) 
    Console.WriteLine("Found in list"); 

Luân phiên sử dụng một số phương thức LINQ (cũng dừng trên phương thức đầu tiên mà nó đạt được)

if( testList.Any( s => s.Equals(keyword, StringComparison.OrdinalIgnoreCase) ) )
    Console.WriteLine("found in list");

Tôi nhận ra đây là một bài viết cũ, nhưng chỉ trong trường hợp bất kỳ ai khác đang tìm kiếm, bạn có thể sử dụng Containsbằng cách cung cấp trường hợp so sánh chuỗi bằng không nhạy cảm như vậy:

using System.Linq;

// ...

if (testList.Contains(keyword, StringComparer.OrdinalIgnoreCase))
{
    Console.WriteLine("Keyword Exists");
}

Điều này đã có sẵn kể từ .net 2.0 theo msdn .

Dựa trên câu trả lời của Adam Sills ở trên - đây là một phương pháp tiện ích mở rộng sạch đẹp cho Chứa ... :)

///----------------------------------------------------------------------
/// <summary>
/// Determines whether the specified list contains the matching string value
/// </summary>
/// <param name="list">The list.</param>
/// <param name="value">The value to match.</param>
/// <param name="ignoreCase">if set to <c>true</c> the case is ignored.</param>
/// <returns>
///   <c>true</c> if the specified list contais the matching string; otherwise, <c>false</c>.
/// </returns>
///----------------------------------------------------------------------
public static bool Contains(this List<string> list, string value, bool ignoreCase = false)
{
    return ignoreCase ?
        list.Any(s => s.Equals(value, StringComparison.OrdinalIgnoreCase)) :
        list.Contains(value);
}

Bạn có thể sử dụng StringComparer:

    var list = new List<string>();
    list.Add("cat");
    list.Add("dog");
    list.Add("moth");

    if (list.Contains("MOTH", StringComparer.OrdinalIgnoreCase))
    {
        Console.WriteLine("found");
    }

Dựa trên câu trả lời của Lance Larsen - đây là một phương thức mở rộng với chuỗi được đề xuất. Hãy thay vì chuỗi.Equals

Rất khuyến khích bạn sử dụng quá tải String.Compare lấy tham số StringComparison. Những quá tải này không chỉ cho phép bạn xác định hành vi so sánh chính xác mà bạn dự định, sử dụng chúng cũng sẽ giúp mã của bạn dễ đọc hơn đối với các nhà phát triển khác. [ Josh miễn phí @ Blog nhóm BCL ]

public static bool Contains(this List<string> source, string toCheck, StringComparison comp)
{
    return
       source != null &&
       !string.IsNullOrEmpty(toCheck) &&
       source.Any(x => string.Compare(x, toCheck, comp) == 0);
}

Bạn đang kiểm tra xem kết quả của IndexOf lớn hơn hoặc bằng 0, nghĩa là trận đấu có bắt đầu ở bất kỳ đâu trong chuỗi không. Hãy thử kiểm tra xem nó có bằng 0 không:

if (testList.FindAll(x => x.IndexOf(keyword, 
                   StringComparison.OrdinalIgnoreCase) >= 0).Count > 0)
   Console.WriteLine("Found in list");

Bây giờ "dê" và "yến" sẽ không khớp, nhưng "dê" và "dê" sẽ. Để tránh điều này, bạn có thể so sánh chiều dài của hai chuỗi.

Để tránh tất cả sự phức tạp này, bạn có thể sử dụng từ điển thay vì danh sách. Khóa của chúng sẽ là chuỗi chữ thường và giá trị sẽ là chuỗi thực. Bằng cách này, hiệu suất không bị tổn thương vì bạn không phải sử dụng ToLowercho mỗi so sánh, nhưng bạn vẫn có thể sử dụng Contains.

Dưới đây là ví dụ về tìm kiếm từ khóa trong toàn bộ danh sách và xóa mục đó:

public class Book
{
  public int BookId { get; set; }
  public DateTime CreatedDate { get; set; }
  public string Text { get; set; }
  public string Autor { get; set; }
  public string Source { get; set; }
}

Nếu bạn muốn xóa một cuốn sách có chứa một số từ khóa trong thuộc tính Văn bản, bạn có thể tạo một danh sách các từ khóa và xóa nó khỏi danh sách các cuốn sách:

List<Book> listToSearch = new List<Book>()
   {
        new Book(){
            BookId = 1,
            CreatedDate = new DateTime(2014, 5, 27),
            Text = " test voprivreda...",
            Autor = "abc",
            Source = "SSSS"

        },
        new Book(){
            BookId = 2,
            CreatedDate = new DateTime(2014, 5, 27),
            Text = "here you go...",
            Autor = "bcd",
            Source = "SSSS"


        }
    };

var blackList = new List<string>()
            {
                "test", "b"
            }; 

foreach (var itemtoremove in blackList)
    {
        listToSearch.RemoveAll(p => p.Source.ToLower().Contains(itemtoremove.ToLower()) || p.Source.ToLower().Contains(itemtoremove.ToLower()));
    }


return listToSearch.ToList();

Tôi có một vấn đề tương tự, tôi cần chỉ số của mặt hàng nhưng nó không nhạy cảm, tôi đã tìm kiếm trên mạng trong vài phút và không tìm thấy gì, vì vậy tôi chỉ viết một phương pháp nhỏ để hoàn thành nó, đây là những gì tôi làm đã làm:

private static int getCaseInvariantIndex(List<string> ItemsList, string searchItem)
{
    List<string> lowercaselist = new List<string>();

    foreach (string item in ItemsList)
    {
        lowercaselist.Add(item.ToLower());
    }

    return lowercaselist.IndexOf(searchItem.ToLower());
}

Thêm mã này vào cùng một tệp và gọi nó như thế này:

int index = getCaseInvariantIndexFromList(ListOfItems, itemToFind);

Hy vọng điều này sẽ giúp, chúc may mắn!