How to Safely Update a GUI from a Background Thread Every 30 Seconds?

Safely update the GUI every 30 seconds from a background thread

This article explores how to use threads safely in your application, avoid errors, and implement the need to update the GUI from a background thread every 30 seconds.

The user initially tried to use a BackgroundWorker and run it in a while loop, but it caused an exception because the background worker thread was not an STA thread.

The correct approach is to separate database calls from GUI updates. Database calls should be performed in a background thread (using BackgroundWorker). After the call is completed, a progress event is triggered to notify the main thread to update the GUI.

User-contributed code demonstrating this approach:

<code class="language-C#">public class UpdateController
{
    private UserController _userController;
    private BackgroundWorker _backgroundWorker;

    // ...

    public void Update()
    {
        _backgroundWorker.RunWorkerAsync();
    }

    void backgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
    {
        // UI 更新
        _userController.UpdateUsersOnMap();
        Update(); // 此处存在潜在问题，递归调用可能导致堆栈溢出
    }

    public void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
    {
        // 大型数据库任务
    }
}</code>

However, users face another challenge: how to trigger updates every 30 seconds. Adding a 10 second sleep in the RunWorkerCompleted event handler is not feasible as it will freeze the GUI.

To solve this problem, a Timer can be used to periodically call the Update method, which in turn initiates a database call and subsequent GUI update. A better solution is to avoid calling RunWorkerCompleted recursively in Update() and instead use System.Timers.Timer or System.Windows.Forms.Timer to control the update frequency. This will ensure the GUI remains responsive and avoid potential stack overflow errors.

The suggested improved code structure is as follows (using System.Timers.Timer):

<code class="language-C#">public class UpdateController
{
    private UserController _userController;
    private BackgroundWorker _backgroundWorker;
    private System.Timers.Timer _timer;

    public UpdateController()
    {
        _backgroundWorker = new BackgroundWorker();
        _backgroundWorker.DoWork += backgroundWorker_DoWork;
        _backgroundWorker.RunWorkerCompleted += backgroundWorker_RunWorkerCompleted;

        _timer = new System.Timers.Timer(30000); // 30秒
        _timer.Elapsed += Timer_Elapsed;
        _timer.AutoReset = true;
    }

    public void Start()
    {
        _timer.Start();
    }

    private void Timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
    {
        _backgroundWorker.RunWorkerAsync();
    }

    void backgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
    {
        // UI 更新，确保在UI线程执行
        _userController.BeginInvoke(new Action(() => _userController.UpdateUsersOnMap()));
    }

    public void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
    {
        // 大型数据库任务
    }
}</code>

This improved code uses Timer to control the update frequency, avoids the risk caused by recursive calls, and uses BeginInvoke to ensure that UI updates are executed on the UI thread, thereby ensuring the responsiveness of the GUI. Remember to call _timer.Stop() at the appropriate time to stop the timer.

The above is the detailed content of How to Safely Update a GUI from a Background Thread Every 30 Seconds?. For more information, please follow other related articles on the PHP Chinese website!