Question

I have a question about solving UI freezing.

Introduction:
I am currently programming an OPC based online alarm reader for a given analyzer tool. This tool received data from an excel sheet, analyzed this data using a rule base and a topology model and shows the results with TreeViewItems.
My task is to replace the excel sheet reader by a real time alarm reader.
That’s done, I can connect my software to server and receive data packages every time new alarms are created.

Problem:
My solution for transport the new data to the main class and from there to the analyzer class is saving the data in a list, adding them to an EventArgs and raising an Event. The handling method in the main class receives this data, starts a new task (Task>) for the analyzer and returns its results to the Main Thread.
This construction should have uncoupled the calculation process from the UI The analyzing process takes about 1.3s with example data. New data arrives every 2 seconds on average. 2 seconds is in the same time the highest refreshing time.

Attached is a code snippet from the handling method

    Task<List<Analyser.ALARM_GROUP>> analysertask = Task.Factory.StartNew<List<Analyser.ALARM_GROUP>>(
                    ()=>
                        {
                            /*if the alarmlist is emty, set the new alarms as alarmlist, 
                             * else add the new alarms to the present list*/
                            if (AlarmList1.Count == 0)
                                AlarmList1 = e.CurrentAlarms;

                            else listModifier.mergeList(e.CurrentAlarms, AlarmList1);

                            /*Start the analysis process in a seperate task and return the Alarm_Group-List*/
                            return Analyser1.startAnalysis(PlantModelReader1, AlarmlogReader1, RuleBaseLoader1, AlarmList1); 
                        });

                Cursor = Cursors.Wait;
                List<Analyser.ALARM_GROUP> alarmGroupList = analysertask.Result;

                showAlarmLog(alarmGroupList);

                Cursor = Cursors.Arrow;

Unfortunately the UI still is stuck when I start analyzing process and I don’t even know if my concept of starting a new thread every two seconds(average appearance time of new alarms) is a reasonable concept.
I guess the problem is inside showAlarmLog but it is a lot of code. If needed I will post this code, too.

I would be thankful for any suggestions on this problem, even a “your concept is crap, try this idea: …” would be good to know.

Kind regards
Larimow

Answer 1

The problem is that this call:

List<Analyser.ALARM_GROUP> alarmGroupList = analysertask.Result;

Blocks the UI thread until the background task is completed.

The way to handle this is to use a continuation task instead of waiting on the result:

Task<List<Analyser.ALARM_GROUP>> analysertask = Task.Factory.StartNew<List<Analyser.ALARM_GROUP>>(
    ()=> {
        // Keep existing code
        return Analyser1.startAnalysis(PlantModelReader1, AlarmlogReader1, RuleBaseLoader1, AlarmList1); 
         });

// Make a continuation here...
analysertask.ContinueWith( t =>
    {
        Cursor = Cursors.Wait;
        List<Analyser.ALARM_GROUP> alarmGroupList = t.Result;
        showAlarmLog(alarmGroupList);
        Cursor = Cursors.Arrow;
    }, TaskScheduler.FromCurrentSynchronizationContext());

By scheduling this as a continuation, it will run when the first task completes. By using TaskScheduler.FromCurrentSynchronizationContext, you say to marshal this back onto the UI thread when it executes.

---

Note that this becomes far easier with .NET 4.5/C# 5. With C# 5, you could write this as:

var analysertask = Task.Run(
    ()=> {
        // Keep existing code
        return Analyser1.startAnalysis(PlantModelReader1, AlarmlogReader1, RuleBaseLoader1, AlarmList1); 
         });

Cursor = Cursors.Wait;
List<Analyser.ALARM_GROUP> alarmGroupList = await analysertask;
showAlarmLog(alarmGroupList);
Cursor = Cursors.Arrow;

This requires the method to be, itself, flagged with the new async keyword, however.