Быстро Текст Предобработки

итеративная замена слов будет самым большим узким местом в вашей реализации. на каждой итерации вы должны сканировать всю строку для стоп-слова, затем операция замены должна выделить новую строку и заполнить ее текстом после замены. Это будет не быстро.

гораздо более эффективным подходом является токенизация строки и выполнение замены потоковым способом. разделить входные данные на отдельные слова разделенные любыми пробелами или символами-разделителями. Вы можете делать это постепенно, поэтому вам не нужно выделять дополнительную память для этого. Для каждого слова (токена) теперь вы можете выполнить поиск в хэш - наборе стоп-слов-если вы найдете совпадение, вы замените его при потоковой передаче окончательного текста на отдельный StringBuilder. Если токен не является стоп-словом, просто передайте его StringBuilder неизмененной. Этот подход должен иметь производительность O(n), так как он сканирует строку только один раз и использует HashSet для выполнения поиска стоп-слов.

Ниже приведен один подход, который я ожидал бы выполнить лучше. Хотя он не полностью потоковый (он использует String.Split() который выделил массив дополнительных строк), он выполняет всю обработку за один проход. Уточнение кода, чтобы избежать выделения дополнительной строки, вероятно, не обеспечит значительного улучшения, так как вам все равно нужно извлечь подстроки для сравнения с вашими стоп-словами.

код ниже возвращает список слов, который исключает все стоп-слова и слова из двух букв или короче результата. Он также использует сравнение без учета регистра в стоп-словах.

public IEnumerable<string> SplitIntoWords( string input,
                                           IEnumerable<string> stopwords )
{
    // use case-insensitive comparison when matching stopwords
    var comparer = StringComparer.InvariantCultureIgnoreCase;
    var stopwordsSet = new HashSet<string>( stopwords, comparer );
    var splitOn = new char[] { ' ', '\t', '\r' ,'\n' };

    // if your splitting is more complicated, you could use RegEx instead...
    // if this becomes a bottleneck, you could use loop over the string using
    // string.IndexOf() - but you would still need to allocate an extra string
    // to perform comparison, so it's unclear if that would be better or not
    var words = input.Split( splitOn, StringSplitOptions.RemoveEmptyEntries );

    // return all words longer than 2 letters that are not stopwords...
    return words.Where( w => !stopwordsSet.Contains( w ) && w.Length > 2 );
}

вместо замены регулярного выражения в цикле, почему бы не динамически построить соответствующее регулярное выражение монстра, которое соответствует любому из ваших стоп-слов, а затем запустить одну замену, заменив ее ничем? Что-то вроде "\b(what|ok|yeah)\b" Если ваш стоп-слова "что", "ОК" И "да". Это кажется более эффективным.

ускорить ваши regexes

ваши regexes могли бы использовать некоторую работу.

например, эта строка:

result = Regex.Replace(result, "(\b"+stopword+"\b)", " ");

использует круглые скобки для захвата стоп-слова для последующего использования, а затем никогда не использует его. Возможно, движок .NET regex достаточно умен, чтобы пропустить захват в этом случае, возможно, нет.

это регулярное выражение слишком сложно:

"(([-]|[.]|[-.]|[0-9])?[0-9]*([.]|[,])*[0-9]+)|(\b\w{1,2}\b)|([^\w])"

• "([-]|[.]|[-.]|[0-9])?" идентичен "([-.0-9])?". (Если вы не пытаетесь спичка.-" - как одна из Ваших возможностей? Полагаю, не сейчас.) Если вам не нужен захват (и вы не в своем примере), то он идентичен "[-.0-9]?".
• "[-.0-9]?" немного избыточно, прежде чем "[0-9]*". Вы можете еще больше упростить его до "[-.]?[0-9]*".
• аналогично, если вам не нужен захват, то "([.]|[,])*" идентичен "[,.]*".

наконец, проверить, если компиляция регулярных выражений может лучше уступить спектакль.

сократить регулярное выражение и манипуляции со строками

построение связки строк, составляющих связку объектов регулярных выражений, а затем отбрасывание их, как вы делаете в этом цикле, вероятно, не очень быстро:

result = Regex.Replace(result, "(\b"+stopword+"\b)", " ");  

попробуйте предварительно обработать стоп-слова в массив объектов Regex или создать одно предварительно скомпилированное регулярное выражение monster (как предлагали другие).

реструктуризировать ваш алгоритм

похоже, вас интересует только обработка стволовых, нон-стоп-слов, текста, а не пунктуации, чисел и т. д.

для этого ваш алгоритм использует следующий подход:

• Stem весь текст (включая стоп-слова?).
• используйте regexes (не обязательно самый быстрый подход), чтобы заменить (что требует постоянной перестановки тела строки) не-слова пробелами.
• использовать регулярные выражения (опять же, не обязательно самый быстрый подход) заменить (снова) стоп-слова пробелами, по одному стоп-слову за раз.

Я начал писать здесь другой подход, но LBushkin меня опередил. Делай, что он говорит. Имейте в виду, как правило, что изменение алгоритма обычно дает большие улучшения, чем микро-оптимизации, такие как улучшение использования регулярных выражений.

вы might работает в Schlemiel проблема художника. В C# (и других языках), когда вы добавляете или объединяете строки, вы фактически создаете совершенно новую строку. Выполнение этого в цикле часто вызывает много выделения памяти, которое в противном случае можно избежать.

Я согласен с mquander, и вот немного больше информации. Каждый раз, когда вы используете регулярное выражение, C# создаст таблицу в соответствии с текстом. Это прекрасно и Денди, если вы вызываете функцию regex только пару раз, но то, что вы делаете здесь, создает около 270 новых таблиц и разбивает их для каждого html-документа.

Я бы попытался просто создать один объект Regex и использовать оператор|, чтобы соответствовать всем различным стоп-словам и первому фильтру. После этого, вы должны использовать regex компиляция сборки, чтобы компилятор генерирует машинный код.

http://en.csharp-online.net/CSharp_Regular_Expression_Recipes%E2%80%94Compiling_Regular_Expressions

вы должны увидеть резкое ускорение только с этим