Висока производителност съдържа търсене в списък с низове в C#

Чувал съм добри неща за Lucene.NET, когато става въпрос за извършване на бързо търсене в пълен текст . Те са свършили работата, за да разберат най-бързите структури от данни и такива за използване. Бих предложил да опитате.

В противен случай можете просто да опитате нещо подобно:

var matches = list.AsParallel().Where(s => s.Contains(searchTerm)).ToList();

Но вероятно няма да ви свали до 100ms.

Опитвали ли сте следното?

list.FindAll(x => x.Contains("YourTerm")).ToList();

По някаква причина List.AsParallel().Where(...) е по-бавен от list.FindAll(...) на моя компютър.

list.AsParallel().Where(x => x.Contains("YourTerm")).ToList();

Надявам се това да ви помогне.

Trie или дърво на суфиксите би помогнало това да стане по-бързо - това е по същество търсенето в пълен текст (обикновено ) използва.

Има реализации в C#, които можете да използвате, вижте също тази SO тема: Търся за прилагането на дървото на суфикса в C#?

Освен това, както беше споменато от @leppie, паралелното изпълнение вероятно вече ще ви осигури увеличението на производителността x3, което търсите. Но след това отново ще трябва да измервате внимателно, без това никой не може да гадае.

Опитвали ли сте да заредите своите низове в List<string> и след това да използвате метода Linq extensions Contains?

var myList = new List<string>();
//Code to load your list goes here...

var searchTerm = "find this";
var match = myList.Contains(searchTerm);

<asp:CompareValidator ControlToCompare="text1" ControlToValidate="text2" ErrorMessage="error" runat="server" Operator="LessThan" Type="Integer" />

public static bool ContainsFast<T>(this IList<T> list, T item)
{
    return list.IndexOf(item) >= 0;
}

Въз основа на тестовете, които направих, този вариант на Contains беше с около 33% по-бърз от моя страна.

Според тези сравнителни показатели, най-бързият начин да проверите дали даден низ се среща в низ е следният:

for (int x = 0; x < ss.Length; x++)
    for (int y = 0; y < sf.Length; y++
        c[y] += ((ss[x].Length - ss[x].Replace(sf[y], String.Empty).Length) / sf[y].Length > 0 ? 1 : 0);

По този начин бихте могли:

1. Преминете през списъка с помощта на конструкция Parallel.For
2. Приложете кода по-горе, за да проверите дали даден низ съдържа това, което търсите. "SS" е низът [] от низове за търсене; "SF" е низът [] от низове за търсене; c[y] е общият брой на всяко намерено.

Очевидно ще трябва да ги адаптирате към вашия List[string] (или каквато и да е структура от данни, която използвате).

Трябва да опитате да използвате класа на речника. Той е много по-бърз от List, защото е индексирано търсене.

Dictionary<String, String> ldapDocument = new Dictionary<String, String>();
//load your list here
//Sample -> ldapDocument.Add("014548787","014548787");
var match = ldapDocument.ContainsKey(stringToMatch);