Wyszukiwanie listy bez rozróżniania wielkości liter

Question

Mam listę testList zawierającą kilka ciągów. Chciałbym dodać nowy ciąg do testList tylko wtedy, gdy jeszcze nie istnieje na liście. Dlatego muszę wykonać wyszukiwanie listy bez uwzględniania wielkości liter i sprawić, by był wydajny. Nie mogę użyć Contains, ponieważ nie uwzględnia to obudowy. Również nie chcę używać ToUpper/ToLower ze względu na wydajność. Natknąłem się na tę metodę, która działa:

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

Działa, ale dopasowuje również częściowe słowa. Jeśli lista zawiera "kozę", nie mogę dodać "owies", ponieważ twierdzi, że "owies" jest już na liście. Czy istnieje sposób, aby skutecznie wyszukiwać listy w sposób niewrażliwy na wielkość liter, gdzie słowa muszą dokładnie odpowiadać? dzięki

Answer 1

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

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

Alternatywnie korzystać z niektórych metod LINQ (które też zatrzymuje się na pierwszej natrafi)

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

Answer 2

jesteś sprawdzanie jeśli wynik IndexOf jest większa lub równa 0, to znaczy, czy rozpoczęciem meczu w dowolnym miejscu w ciągu znaków. Spróbuj sprawdzić, czy to równa do 0:

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

Now „koza” i „owies” nie pasuje, ale „koza” i „Goa” wola. Aby tego uniknąć, możesz porównać długości dwóch łańcuchów.

Aby uniknąć wszystkich tych komplikacji, można użyć słownika zamiast listy. Ich klucz byłby ciągiem z małą literą, a wartość byłaby prawdziwym ciągiem znaków. W ten sposób wydajność nie zostanie zraniona, ponieważ nie musisz używać ToLower dla każdego porównania, ale nadal możesz używać Contains.

Answer 3

podstawie Adam parapety odpowiedzi powyżej - tu jest ładny, czysty sposób rozszerzenia dla Zawiera ... :)

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

Answer 4

miałem podobny problem, musiałem indeks pozycji, ale to musiał być przypadek nieczuły, rozejrzałem się w internecie na kilka minut i nic nie znalazłem, więc po prostu napisałem mały sposób, aby to zrobić, oto co zrobiłem:

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, a wezwanie to tak:

int index = getCaseInvariantIndexFromList(ListOfItems, itemToFind); 

Mam nadzieję, że to pomoże, powodzenia!

Answer 5

Zdaję sobie sprawę, że jest to stary post, ale na wszelki wypadek ktoś patrzy, ty może korzystanie Contains dostarczając wielkość liter ma znaczenie porównywarka równości ciąg tak:

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

ta jest dostępna od .net 2.0 zgodnie z msdn.

Answer 6

podstawie Lance Larsen odpowiedź - oto metodę rozszerzenia z zalecaną string.Compare zamiast string.Equals

Jest wysoce zalecane, aby użyć przeciążenie String.Compare która przyjmuje parametr StringComparison. Te przeciążenia pozwalają nie tylko zdefiniować dokładne zachowanie porównawcze, które zamierzałeś, ale także sprawią, że Twój kod stanie się bardziej czytelny dla innych programistów. [Josh Free @ BCL Team Blog]

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