public void FinalizeUpdate(bool needRestart) { try { // Check if an update is pending if (_updateVersion == null) { return; } // Check if the updater has already been launched if (_updaterLaunched) { return; } // Launch the updater _updateManager.LaunchUpdater(_updateVersion, needRestart); _updaterLaunched = true; } catch (UpdaterAlreadyLaunchedException) { } catch (LockFileNotAcquiredException) { } }
public void FinalizeUpdate(bool needRestart) { if (!_settingsService.IsAutoUpdateEnabled) { return; } if (_updateVersion == null || !_updatePrepared || _updaterLaunched) { return; } try { _updateManager.LaunchUpdater(_updateVersion, needRestart); _updaterLaunched = true; } catch (UpdaterAlreadyLaunchedException) { // Ignore race conditions } catch (LockFileNotAcquiredException) { // Ignore race conditions } }
public void FinalizePendingUpdates() { if (!_settingsService.IsAutoUpdateEnabled) { return; } try { // Get last prepared update var updateVersion = GetLastPreparedUpdate(); if (updateVersion == null) { return; } // Don't update if the prepared update is a downgrade if (App.Version >= updateVersion) { return; } // Launch updater and restart _updateManager.LaunchUpdater(updateVersion); Environment.Exit(0); } catch (UpdaterAlreadyLaunchedException) { // Ignore race conditions } catch (LockFileNotAcquiredException) { // Ignore race conditions } }
public async void CheckForUpdate() { var check = await _updateManager.CheckForUpdatesAsync(); // If there are none, notify user and return if (!check.CanUpdate) { return; } else { System.Windows.Forms.MessageBox.Show("There are updates available."); } // Prepare the latest update await _updateManager.PrepareUpdateAsync(check.LastVersion); // Launch updater and exit _updateManager.LaunchUpdater(check.LastVersion); if (System.Diagnostics.Process.GetProcessesByName(System.IO.Path.GetFileNameWithoutExtension(System.Reflection.Assembly.GetEntryAssembly().Location)).Count() > 0) { //System.Windows.MessageBox.Show("Closed to update", "WallEngine Updater", System.Windows.MessageBoxButton.OK); System.Diagnostics.Process.GetCurrentProcess().Kill(); } }
private async void button_Click(object sender, EventArgs e) { if (button.Text == BUTTON_CHECK_FOR_UPDATES) { CheckForUpdates(); } if (button.Text == BUTTON_UPDATE_NOW) { DialogResult result = MessageBox.Show( $"There is an update available. Your current version is {currentVersion}, the latest version is {checkForUpdatesResult.LastVersion}. Would you like to update to the latest version?", "Update Available", MessageBoxButtons.YesNo ); if (result == DialogResult.Yes) { UpdateStarted?.Invoke(this, EventArgs.Empty); label.Text = LABEL_UPDATING; button.Hide(); progressBar.Show(); // Prepare the latest update await updateManager.PrepareUpdateAsync(checkForUpdatesResult.LastVersion, progress); // Launch updater and exit updateManager.LaunchUpdater(checkForUpdatesResult.LastVersion); Application.Exit(); } } }
public void FinalizePendingUpdates() { if (!_settingsService.IsAutoUpdateEnabled) { return; } try { var updateVersion = GetLastPreparedUpdate(); if (updateVersion == null) { return; } if (App.Version >= updateVersion) { return; } _updateManager.LaunchUpdater(updateVersion); Environment.Exit(0); } catch (UpdaterAlreadyLaunchedException) { // Ignore race conditions } catch (LockFileNotAcquiredException) { // Ignore race conditions } }
private async void checkForUpdatesButton_Click(object sender, EventArgs e) { // Check for updates var check = await updateManager.CheckForUpdatesAsync(); // If there are none, notify user and return if (!check.CanUpdate) { MessageBox.Show("There are no updates available."); return; } else { DialogResult result = MessageBox.Show( $"There is an update available. Your current version is {currentVersion}, the latest version is {check.LastVersion}. Would you like to update to the latest version?", "Update Available", MessageBoxButtons.YesNo ); if (result == DialogResult.Yes) { // Prepare the latest update await updateManager.PrepareUpdateAsync(check.LastVersion); // Launch updater and exit updateManager.LaunchUpdater(check.LastVersion); Application.Exit(); } } }
public void FinalizeUpdate() { // Check if an update is pending if (_updateVersion == null) { return; } // Check if the update has already been finalized if (_updateFinalized) { return; } // Launch the updater _manager.LaunchUpdater(_updateVersion, NeedRestart); _updateFinalized = true; }
public void FinalizeUpdate(bool needRestart) { // Check if an update is pending if (_updateVersion == null) { return; } // Check if the updater has already been launched if (_updaterLaunched) { return; } // Launch the updater _updateManager.LaunchUpdater(_updateVersion, needRestart); _updaterLaunched = true; }
/// <summary> /// Checks for new version and performs an update if available. /// </summary> public static async Task CheckPerformUpdateAsync(this IUpdateManager manager, bool restart = true, IProgress <double>?progress = null, CancellationToken cancellationToken = default) { // Check var result = await manager.CheckForUpdatesAsync(cancellationToken); if (!result.CanUpdate || result.LastVersion == null) { return; } // Prepare await manager.PrepareUpdateAsync(result.LastVersion, progress, cancellationToken); // Apply manager.LaunchUpdater(result.LastVersion, restart); // Exit Environment.Exit(0); }
public bool InstallPendingUpdate(bool withRestart = true) { var lastPreparedVersion = _updateManager.GetPreparedUpdates().LastOrDefault(); if (lastPreparedVersion != null) { try { _updateManager.LaunchUpdater(lastPreparedVersion, withRestart); return(true); } catch (Exception e) when(e is UpdaterAlreadyLaunchedException || e is LockFileNotAcquiredException) { // Ignore race conditions } } return(false); }
public async Task PerformUpdate() { if (CheckForUpdatesResult.CanUpdate) { UpdateStarted?.Invoke(this); // Prepare the latest update await updateManager.PrepareUpdateAsync(CheckForUpdatesResult.LastVersion, Progress); // Launch updater and exit updateManager.LaunchUpdater(CheckForUpdatesResult.LastVersion); infoForm?.Close(); Program.mainForm.FormClosing -= Program.mainForm.MainForm_FormClosing; Utils.SaveURLs(Program.mainForm.Model.Boards, Program.mainForm.Model.Threads); Application.Exit(); } }
public void FinalizeUpdate(bool needRestart) { try { if (_updateVersion == null || _updaterLaunched) { return; } _updateManager.LaunchUpdater(_updateVersion, needRestart); _updaterLaunched = true; } catch (UpdaterAlreadyLaunchedException) { // Ignore race conditions } catch (LockFileNotAcquiredException) { // Ignore race conditions } }
/// <summary> /// Checks for new version and performs an update if available. /// </summary> public static async Task CheckPerformUpdateAsync(this IUpdateManager manager, bool restart = true, IProgress <double> progress = null, CancellationToken cancellationToken = default(CancellationToken)) { manager.GuardNotNull(nameof(manager)); // Check var result = await manager.CheckForUpdatesAsync().ConfigureAwait(false); if (!result.CanUpdate) { return; } // Prepare await manager.PrepareUpdateAsync(result.LastVersion, progress, cancellationToken).ConfigureAwait(false); // Apply manager.LaunchUpdater(result.LastVersion, restart); // Exit Environment.Exit(0); }
public async Task PerformUpdateAsync(ProgressDialogController progressDialog) { var result = await _updateManager.CheckForUpdatesAsync(); if (!result.CanUpdate) { return; } var progress = new Progress <double>(); progress.ProgressChanged += (s, e) => { progressDialog.SetProgress(e); }; await _updateManager.PrepareUpdateAsync(result.LastVersion, progress); _updateManager.LaunchUpdater(result.LastVersion); Environment.Exit(0); }
/// <summary> /// Launches an external executable that will apply an update to given version, once this application exits. /// The updater can be instructed to also restart the application after it's updated. /// If the application is to be restarted, it will receive the same command line arguments as it did initially. /// </summary> public static void LaunchUpdater(this IUpdateManager manager, Version version, bool restart = true) => manager.LaunchUpdater(version, restart, EnvironmentEx.GetCommandLineWithoutExecutable());