Ответ 1

Это зависит от

Хотя манипуляции с строками обычно будут несколько быстрее, фактическая производительность сильно зависит от ряда факторов, в том числе:

• Сколько раз вы анализируете регулярное выражение
• Насколько умно вы напишете свой строковый код
• Предварительно скомпилировано ли регулярное выражение

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

Ответ 2

Я сделал несколько тестов с двумя функциями, называемыми FunctionOne (строковые операции) и FunctionTwo (Regex). Они должны оба получить все совпадения между '<' и ' > '.

критерий № 1:

• время называется: 1'000'000
• вход: 80 символов
• duration (строковые операции //FunctionOne ): 1.12 сек
• duration (операция регулярного выражения //FunctionTwo ): 1,88 с

> # 2:

• время называется: 1'000'000
• ввод: 2000 символов
• duration (строковые операции): 27.69 сек
• duration (операции с регулярным выражением): 41.436 сек

Заключение. Операции с строками почти всегда будут бить регулярные выражения, если они запрограммированы эффективно. Но чем более сложным он становится, тем сложнее будет то, что струнные операции могут не отставать не только от производительности, но и от обслуживания.

Код FunctionOne

  private void FunctionOne(string input)
        {
               var matches = new List<string>();
        var match = new StringBuilder();
        Boolean startRecording = false;
        foreach (char c in input)
        {
            if (c.Equals('<'))
            {
                startRecording = true;
                continue;
            }

            if (c.Equals('>'))
            {
                    matches.Add(match.ToString());
                    match = new StringBuilder();
                    startRecording = false;
            }

            if (startRecording)
            {
                match.Append(c);
            }
        }
        }

Функция кода 2

Regex regx = new Regex("<.*?>");  
private void FunctionTwo(string input)
    {
        Match m = regx.Match(input);
        var results = new List<string>();
        while (m.Success)
        {
            results.Add(m.Value);
            m = m.NextMatch();
        }
    }

Ответ 3

Операции строк всегда будут быстрее, чем операции регулярного выражения. Если, конечно, вы не выполняете строковые операции неэффективно.

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

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

Ответ 4

Я некоторое время выполнял профилирование в С#, сравнивая следующее:

1) LINQ to Objects.

2) Лямбда-выражения.

3) Традиционный итерационный метод.

Все 3 метода были протестированы как с регулярными выражениями, так и без них. Заключение в моем тестовом случае было ясным, что регулярные выражения довольно медленнее, чем не-Regex во всех трех случаях при поиске строк в большом количестве текста.

Вы можете прочитать подробности в своем блоге: http://www.midniteblog.com/?p=72