c# - Is there A Faster Way to Highlighting Regex Matches (RichTextBox)

Question

I use RichTextBox for testing REGEX expression, with the code like:

rtbMain.SelectAll();
rtbMain.SelectionColor = Color.Black;
rtbMain.SelectionBackColor = Color.White;
Regex regex = new Regex(txtRegexPattern.Text, regexOptions);
Match matches = regex.Match(txtTest.Text);
while (matches.Success)
{
    rtbMain.Select(matches.Index, match.Length);
    rtbMain.SelectionColor = Color.Red;
    rtbMain.SelectionBackColor = Color.Black;
}

But this method becomes too slow as soon as there are more than a few thousand (1000+) characters to be highlighted. I know I could delay processing, so that code gives user a chance to enter the whole Regular Expression, but still I think RichTextBox highlighting is working too slow.

I've searched the Google for different approaches and ways to speed up current solution, but I didn't have luck. I noticed that there are a few text editors which allow "syntax highlighting" (like ScintillNET, Avalon,...) but they use XML as input, so I think using them for my project (generating XML on every KeyUp event) wouldn't be the "best practice".

I have found and tested a "Fast colored Textbox" here: https://github.com/PavelTorgashov/FastColoredTextBox ...but the problem with this one is that it replaces the paste content while it uses its own new-line and tab character, and I cant use it in REGEX tester.

Is there any faster way to highlight all matches, maybe using a different user control?

EDIT:

APPROACH 1: Would generating the underlying RTF document be faster? I tried but had some problems with special characters, so I could test highlighting of the whole document, but it seemed to work quite fast with normal characters in a single line. I paused working on this since I read constructing RTF's can be quite hard, and I think I couldn't use none of the existing RTF libraries.

APPROACH 2: I am able to get only the displayed portion of RichTextBox, so I was thinking to only highlight that part. I guess this would significantly reduce processing (depends on RTB size), but I would need to trigger highlighting every time user scrolls; I'm not sure this would work well and create a decent user experience, so haven't tried it out yet.

Would anyone recommend any of the approaches above or maybe any others?

Answer 1

First:

The RichTextBox has an inherent problem: It is very slow in .NET. I found a solution how to make it 120 times faster. May be you try it out: C# RichEditBox has extremely slow performance (4 minutes loading) SOLVED

Second:

Building the RTF code from the scratch is far the fastest solution. Have a look a my article on codeproject. There is a RTF builder class that is reusable: http://www.codeproject.com/Articles/23513/SQL-Editor-for-Database-Developers

Answer 2

Please check Expresso at http://www.codeproject.com/Articles/3669/Expresso-A-Tool-for-Building-and-Testing-Regular-E

I have been using this program for editing and evaluating regex for years.

Answer 3

I have a doubt that you have setup your While loop in an incorrect manner.

Try something like this: (Untested, but will give you an idea how to troubleshoot this problem)

rtbMain.SelectAll();
rtbMain.SelectionColor = Color.Black;
rtbMain.SelectionBackColor = Color.White;
Regex regex = new Regex(txtRegexPattern.Text, regexOptions);
MatchCollection matches = regex.Matches(txtTest.Text);

if(matches.Count > 0)
{
   foreach(Match m in matches)
   {
      rtbMain.Select(m.Index, m.Length);
      rtbMain.SelectionColor = Color.Red;
      rtbMain.SelectionBackColor = Color.Black;
   }
}
else
{
   Debug.Print("No matches found"); // See "Output" Window
}

EDIT

I did some workaround related to highlight RTF text and first thing I found is the mostly time taken by the process was these lines:

  rtbMain.SelectionColor = Color.Red;
  rtbMain.SelectionBackColor = Color.Black;

I tried selecting the text using SelectionStart and SelectionEnd properties instead .Select(), but NO change has been observed.

Regarding your first point which is related to constructing equivalent RTF, I tried that too but it is difficult to construct an equivalent RTF since there are lot of stuff there which needs to be handle. If it can be done the process time will be around < 1.5 seconds for more than 31k matches (a result of basic test on a specific sample).

So, I would suggest you to do it via THREADING and split task in two threads:

Here is an example source code: (For worst case i found around 31341 matches and process took 4 seconds to highlight)

    // declare variables either globally or in the same method
    MatchCollection mcoll;
    Stopwatch s;
    int callbackCount = 0;
    List<Match> m1 = null;
    List<Match> m2 = null;

    private void btnHighlight_Click(object sender, EventArgs e)
    {
        //reset any exisiting formatting
        rtbMain.SelectAll();
        rtbMain.SelectionBackColor = Color.White;
        rtbMain.SelectionColor = Color.Black;
        rtbMain.DeselectAll();

        s = new Stopwatch();
        s.Start();

        Regex re = new Regex(@"(.)", RegexOptions.Compiled); // Notice COMPILED option
        mcoll = re.Matches(rtbMain.Text);

        // Break MatchCollection object into List<Matches> which is exactly half in size
        m1 = new List<Match>(mcoll.Count / 2);
        m2 = new List<Match>(mcoll.Count / 2);

        for (int k = 0; k < mcoll.Count; k++)
        {
            if (k < mcoll.Count / 2)
                m1.Add(mcoll[k]);
            else
                m2.Add(mcoll[k]);
        }

        Thread backgroundThread1 = new Thread(new ThreadStart(() => {
            match1(null, null);
        }));
        backgroundThread1.Start();

        Thread backgroundThread2 = new Thread(new ThreadStart(() =>
        {
            match2(null, null);
        }));
        backgroundThread2.Start();
    }

    public void match1(object obj, EventArgs e)
    {
        for (int i=0; i < m1.Count; i += 1)
        {
            if (rtbMain.InvokeRequired)
            {
                EventHandler d = new EventHandler(match1);
                rtbMain.Invoke(d);
            }
            else
            {
                rtbMain.Select(m1[i].Index, m1[i].Length);
                rtbMain.SelectionBackColor = Color.Black;
                rtbMain.SelectionColor = Color.Red;
            }
        }
        stopTimer();
    }

    public void match2(object obj, EventArgs e)
    {
        for (int j=0; j < m2.Count; j += 1)
        {
            if (rtbMain.InvokeRequired)
            {
                EventHandler d = new EventHandler(match2);
                rtbMain.Invoke(d);
            }
            else
            {
                rtbMain.Select(m2[j].Index, m2[j].Length);
                rtbMain.SelectionBackColor = Color.Black;
                rtbMain.SelectionColor = Color.Red;
            }
        }
        stopTimer();
    }

    void stopTimer()
    {
        callbackCount++;

        if (callbackCount == 2) // 2 because I am using two threads.
        {
            s.Stop();
            // Check Output Window
            Debug.Print("Evaluated in : " + s.Elapsed.Seconds.ToString());
        }
    }

Since as you posted it takes around 30 sec to manipulate, hope 4 sec is bearable and user can be engaged by some loading screen as the other online converters do like Rubular and DerekSlager's .Net regex tester does.

Don't forget to have a look at Why Regex.Compiled preferred.