[WPF] Threading - Parsing script in background thread

[NickThissen]

Hi,

I am building a simple script editor application in WPF which parses the text in the script into constructs such as 'classes', 'events', etc (these don't really relate to .NET classes and events, it's a game script).

Every time the script text changes (eg: the user types into the editor), the script needs to be parsed again so that any possible new classes/events can be picked up. The parsed classes and events are shown in two ComboBoxes above the editor, similar to Visual Studio.

The problem is that large scripts take a slight amount of time to parse, and this causes the UI to feel sluggish when typing. I am sure I cannot improve the parsing speed any more (and I'm not going to dump the code here and leave you to figure it out), so the obvious approach (at least to me) seems multithreading.

I want to run the parsing in a background thread, so that the UI does not freeze up for a few milliseconds when the user is typing. The logic seems easy enough; if the user types 1 letter, a background thread is started that starts parsing the script. When that finishes, it sends its results back to the window so it can show the new classes/events. Should the user type again during the time that the background thread is parsing (which will happen if someone is typing at a moderate to fast pace), then the current thread is simply aborted (any results it comes up with are out of date anyway) and a new thread is started.

I cannot figure out how to do this though, I've never been any good at threading. I keep getting problems where some object tries to access some other object from a different thread, which is of course not possible.

The most important code is the Script class:

public class Script : NotifyObject
    {
        // The container class that holds the thread and the parsing logic
        private ScriptParseThreadContainer _ScriptParseThread;
 
        public Script(string text)
        {
            _ParsedWords = new ObservableCollection<string>();
            this.Text = text;
        }
 
        private string _Text;
        public string Text
        {
            get { return _Text; }
            set
            {
                _Text = value;
                this.ParseText();
                this.OnPropertyChanged(() => this.Text);
            }
        }
 
        private readonly ObservableCollection<string> _ParsedWords;
        public ObservableCollection<string> ParsedWords { get { return _ParsedWords; } }
 
        private void ParseText()
        {
            // Create a new script parse thread container
            if (_ScriptParseThread != null) _ScriptParseThread.Dispose();
            _ScriptParseThread = new ScriptParseThreadContainer(this.Text);
 
            // Hook up event and start it
            _ScriptParseThread.ParsingComplete += ScriptParsingComplete;
            _ScriptParseThread.Start();
        }
 
        private void ScriptParsingComplete(object sender, EventArgs e)
        {
            // When the thread is done parsing, load the resulting words into this ParsedWords collection so the Window can display them
            this.ParsedWords.Clear();
            foreach (var word in _ScriptParseThread.ParsedWords)
            {
                this.ParsedWords.Add(word);
            }
            _ScriptParseThread.Dispose();
        }
 
        public class ScriptParseThreadContainer : IDisposable
        {
            public ScriptParseThreadContainer(string text)
            {
                _Thread = new Thread(ParseText);
                this.Text = text;
                _ParsedWords = new ObservableCollection<string>();
            }
 
            public event EventHandler ParsingComplete;
 
            public Thread _Thread;
            public string Text { get; set; }
 
            private readonly ObservableCollection<string> _ParsedWords;
            public ObservableCollection<string> ParsedWords { get { return _ParsedWords; } }
 
            public void Start()
            {
                _Thread.Start();
            }
 
            public void ParseText()
            {
                this.ParsedWords.Clear();
                var words = this.Text.Split(' ');
                foreach (var word in words)
                {
                    this.ParsedWords.Add(word);
                }
 
                if (this.ParsingComplete != null)
                {
                    this.ParsingComplete(this, EventArgs.Empty);
                }
            }
 
            public void Dispose()
            {
                _Thread.Abort();
                _Thread = null;
            }
        }
    }

It has properties 'Text' (just the script text) and 'ParsedWords'. For the sake of example I am just extracting the separate words from the script, as the parsing details are not important.

When the Text property changes, any running parsing thread is aborted and a new one is started. The thread is encapsulated in a class ScriptParseThreadContainer (so that I can pass values such as the Text and retrieve the resulting list of words when it is finished) which extracts all separate words ('parses the text'), puts them in an ObservableCollection<string> (I suppose any collection/array could have done) and then raises the ParsingComplete event.

The event handler for this ParsingComplete event simply reads the ParsedWords collection and puts each word in its own ParsedWords collection. The MainWindow has a ComboBox that is bound to this property so that it displays that collection.


This doesn't seem to work. It seems that the event handler for ParsingComplete is still raised on the background thread, so that I am accessing the Script.ParsedWords collection from a different thread that created it resulting in an error.



How can I do this? It shouldn't be that hard, right? I just need to run a thread that puts some strings into a collection, then I need it to notify me when it is finished, at which point I put those words in my own collection where the Window can read them...

Any help? Thanks!


EDIT
I might have gotten a bit further, not there yet though...

I suppose I have to somehow put the words from one collection to the other in a method which should then be called from the UI thread. Similar to how accessing controls from background threads works in Winforms? In that case I create a delegate and invoke that via the Control.Invoke method. I don't have any control here to call Invoke on though, so I found the next best thing: Dispatcher.CurrentDispatcher?

private void ScriptParsingComplete(object sender, EventArgs e)
        {
            // When the thread is done parsing, load the resulting words into this ParsedWords collection so the Window can display them
            var del = new LoadWordsDelegate(LoadWords);
            Dispatcher.CurrentDispatcher.BeginInvoke(del);
            _ScriptParseThread.Dispose();
        }
 
        private delegate void LoadWordsDelegate();
        private void LoadWords()
        {
            this.ParsedWords.Clear();
            foreach (var word in _ScriptParseThread.ParsedWords)
            {
                this.ParsedWords.Add(word);
            }
        }

This seems more appropriate, but still doesn't work. When using Dispatcher.CurrentDispatcher.BeginInvoke, the LoadWords method is never called. I can now type into the textbox without errors, but the ComboBox is never filled and stays empty. When I replace that line by Dispatcher.CurrentDispatcher.Invoke, the method is called, but still on the background thread it seems... It results in the same error as if I don't use the delegate invoking at all.