Wyszukiwanie list bez rozróżniania wielkości liter

Mam listę testListzawierającą kilka ciągów. Chciałbym dodać nowy ciąg do testListjedynego, jeśli nie istnieje jeszcze na liście. Dlatego muszę przeszukiwać listę bez rozróżniania wielkości liter i sprawić, by była wydajna. Nie mogę używać, Containsbo to nie uwzględnia obudowy. Nie chcę też używać ToUpper/ToLowerze względu na wydajność. Trafiłem na tę metodę, która działa:

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

To działa, ale dopasowuje również częściowe słowa. Jeśli lista zawiera słowo „koza”, nie mogę dodać słowa „owies”, ponieważ twierdzi, że „owies” jest już na liście. Czy istnieje sposób na efektywne przeszukiwanie list bez rozróżniania wielkości liter, gdzie słowa muszą dokładnie pasować? dzięki

Zamiast String.IndexOf użyj String.Equals, aby upewnić się, że nie masz częściowych dopasowań. Nie używaj także FindAll, ponieważ przechodzi przez każdy element, użyj FindIndex (zatrzymuje się na pierwszym, który trafi).

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

Alternatywnie użyj niektórych metod LINQ (które również zatrzymują się na pierwszej trafionej)

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

Zdaję sobie sprawę, że jest to stary post, ale tylko w przypadku ktoś szuka, to można wykorzystać Containspoprzez dostarczenie wielkość liter ma znaczenie porównywarka równości ciąg jak w przykładzie:

using System.Linq;

// ...

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

To było dostępne od .net 2.0 zgodnie z msdn .

Na podstawie powyższej odpowiedzi Adama Sillsa - oto ładna, czysta metoda rozszerzeń dla Zawartości ... :)

///----------------------------------------------------------------------
/// <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);
}

Możesz użyć StringComparer:

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

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

Na podstawie odpowiedzi Lance'a Larsena - oto metoda rozszerzenia z zalecanym ciągiem znaków: porównaj zamiast ciągów znaków.

Zdecydowanie zaleca się użycie przeciążenia String.Compare, które przyjmuje parametr StringComparison. Te przeciążenia nie tylko umożliwiają zdefiniowanie dokładnego zachowania porównawczego, które zamierzałeś, ale ich użycie sprawi, że Twój kod będzie bardziej czytelny dla innych programistów. [ Blog zespołu Josh Free @ 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);
}

Sprawdzasz, czy wynik IndexOf jest większy lub równy 0, co oznacza, czy dopasowanie zaczyna się w dowolnym miejscu w ciągu. Spróbuj sprawdzić, czy jest równe 0:

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

Teraz „koza” i „owies” nie będą pasować, ale „koza” i „goa” tak. Aby tego uniknąć, możesz porównać długości dwóch strun.

Aby uniknąć tych wszystkich komplikacji, możesz użyć słownika zamiast listy. Kluczem byłby ciąg małych liter, a wartością byłby prawdziwy ciąg. W ten sposób wydajność nie zaszkodzi, ponieważ nie musisz używać ToLowerdla każdego porównania, ale nadal możesz używać Contains.

Poniżej znajduje się przykład wyszukiwania słowa kluczowego na całej liście i usuwania tego elementu:

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; }
}

Jeśli chcesz usunąć książkę, która zawiera słowo kluczowe we właściwości Text, możesz utworzyć listę słów kluczowych i usunąć ją z listy książek:

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();

Miałem podobny problem, potrzebowałem indeksu pozycji, ale musiał być bez rozróżniania wielkości liter, rozejrzałem się po sieci przez kilka minut i nic nie znalazłem, więc napisałem małą metodę, aby to zrobić, oto co zrobiłem zrobił:

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());
}

Dodaj ten kod do tego samego pliku i nazwij go w ten sposób:

int index = getCaseInvariantIndexFromList(ListOfItems, itemToFind);

Mam nadzięję, że to pomogło, powodzenia!