从非 UI 线程重新启动 WPF 应用程序

Question

In my WPF app I need to run a quick routine on startup that checks for a new available version. If the version is available, we do the update and then would like to immediately restart the app. Since this is run before the main window appears to the user, it simply appears as though the app took a split second longer to start up.

We're using Squirrel.Windows for our updater. I've made the class below to handle checking for/applying updates.

public class UpdateVersion
{
    private readonly UpdateManager _updateManager;

    public Action<int> Progress;
    public event Action Restart;
    public UpdateVersion(string squirrelUrl)
    {
        _updateManager = new UpdateManager(squirrelUrl);
    }

    public async Task UpdateVersions()
    {
        using (_updateManager)
        {
            UpdateInfo updateInfo = await _updateManager.CheckForUpdate(progress:Progress);
            if (updateInfo.CurrentlyInstalledVersion == null)
            {
                if (updateInfo.FutureReleaseEntry != null)
                {
                    await _updateManager.UpdateApp(Progress);

                    // Job crashes here
                    Restart?.Invoke();
                }
            }
            else if (updateInfo.CurrentlyInstalledVersion.Version < updateInfo.FutureReleaseEntry.Version)
            {
                await _updateManager.UpdateApp(Progress);

                // Job crashes here
                Restart?.Invoke();
            }
        }
    }
}

Unfortunately Squirrel has made their update process async only, which means the CheckForUpdate and UpdateApp method must use await , making the entire update method asynchronous. I assign the asnyc call to a Task , then simply .Wait() for the update to finish.

The problem comes when I try to restart my app. Based on what I've read, I need to use Dispatcher.Invoke to call the restart due to the fact I am on a non-UI thread when performing the update. However, despite the code below, I still get the same error message:

The Calling thread cannot access this object because a different thread owns it

Any idea how to correctly implement Dispatcher.Invoke in order to restart the app?

        // Instantiate new UpdateVersion object passing in the URL
        UpdateVersion updateVersion = new UpdateVersion(System.Configuration.ConfigurationManager.AppSettings.Get("SquirrelDirectory"));

        // Assign Dispatch.Invoke as Restart action delegate
        updateVersion.Restart += () =>
        {
            Dispatcher.Invoke(() =>
            {
                Process.Start(ResourceAssembly.Location);
                Current.Shutdown();
            });
        };

        // This is here for debugging purposes so I know the update is occurring
        updateVersion.Progress += (count) =>
        {
            Debug.WriteLine($"Progress.. {count}");
        };

        var task = Task.Run(async () => { await updateVersion.UpdateVersions(); });
        task.Wait();

EDIT

Below is a screen shot of the Target attribute of the Restart action. The debugger was paused at the Restar?.Invoke line from above.

Answer 1

Instead of trying to convert asynchronous programming to the old event based pattern, just use it properly. You don't need events to detect when an asynchronous operation finished, nor do you need Invoke to move back to the UI thread. await takes care of both.

You could write code as simple as this:

static readonly SemanticVersion ZeroVersion = new SemanticVersion(0, 0, 0, 0);


private async void Application_Startup(object sender, StartupEventArgs e)
{
    await CheckForUpdatesAsync();
}

private async Task CheckForUpdatesAsync()
{
    string squirrelUrl = "...";


    var updateProgress = new Progress<int>();
    IProgress<int> progress = updateProgress;

    //Create a splash screen that binds to progress and show it
    var splash = new UpdateSplash(updateProgress);
    splash.Show();

    using (var updateManager = new UpdateManager(squirrelUrl))
    {

        //IProgress<int>.Report matches Action<i>
        var info = await updateManager.CheckForUpdate(progress: progress.Report);

        //Get the current and future versions. 
        //If missing, replace them with version Zero
        var currentVersion = info.CurrentlyInstalledVersion?.Version ?? ZeroVersion;
        var futureVersion = info.FutureReleaseEntry?.Version ?? ZeroVersion;

        //Is there a newer version?
        if (currentVersion < futureVersion)
        {
            await updateManager.UpdateApp(progress.Report);
            Restart();
        }
    }
    splash.Hide();
}

private void Restart()
{
    Process.Start(ResourceAssembly.Location);
    Current.Shutdown();
}

This is just enough code to extract to a separate class:

private async void Application_Startup(object sender, StartupEventArgs e)
{
        var updater = new Updater();
        await updater.CheckForUpdatesAsync(...);
}

// ...

class Updater
{
    static readonly SemanticVersion ZeroVersion = new SemanticVersion(0, 0, 0, 0);


    public async Task CheckForUpdatesAsync(string squirrelUrl)
    {
        var updateProgress = new Progress<int>();
        IProgress<int> progress = updateProgress;

        //Create a splash screen that binds to progress and show it
        var splash = new UpdateSplash(updateProgress);
        splash.Show();

        using (var updateManager = new UpdateManager(squirrelUrl))
        {

            var updateInfo = await updateManager.CheckForUpdate(progress: progress.Report);

            //Get the current and future versions. If missing, replace them with version Zero
            var currentVersion = updateInfo.CurrentlyInstalledVersion?.Version ?? ZeroVersion;
            var futureVersion = updateInfo.FutureReleaseEntry?.Version ?? ZeroVersion;

            //Is there a newer version?
            if (currentVersion < futureVersion)
            {
                await updateManager.UpdateApp(progress.Report);
                Restart();
            }
        }
        splash.Hide();
    }

    private void Restart()
    {
        Process.Start(Application.ResourceAssembly.Location);
        Application.Current.Shutdown();
    }
}

Answer 2

So the actual exception is somewhere in the Restart handler is trying to access the MainWindow get property from another thread based on the stack trace. This is a complete guess, but I would store the original Dispatcher in the OnStartup method and use the stored Dispatcher in the Restart event handler.

Answer 3

Why you are not using SplashScreen ? This SplashScreen would check for new versions, and either download updates, or start the old application.

A lovely tutorial to get you started : EASILY CREATE A WPF SPLASH SCREEN WITH STATUS UPDATES VIA MVVM