ArchiSteamFarm.ASF.CheckForUpdate C# (CSharp) Метод

		internal static async Task CheckForUpdate(bool updateOverride = false) {
			string exeFile = Assembly.GetEntryAssembly().Location;
			if (string.IsNullOrEmpty(exeFile)) {
				ArchiLogger.LogNullError(nameof(exeFile));
				return;
			}

			string oldExeFile = exeFile + ".old";

			// We booted successfully so we can now remove old exe file
			if (File.Exists(oldExeFile)) {
				// It's entirely possible that old process is still running, allow at least a second before trying to remove the file
				await Task.Delay(1000).ConfigureAwait(false);

				try {
					File.Delete(oldExeFile);
				} catch (Exception e) {
					ArchiLogger.LogGenericException(e);
					ArchiLogger.LogGenericError("Could not remove old ASF binary, please remove " + oldExeFile + " manually in order for update function to work!");
				}
			}

			if (Program.GlobalConfig.UpdateChannel == GlobalConfig.EUpdateChannel.None) {
				return;
			}

			if ((AutoUpdatesTimer == null) && Program.GlobalConfig.AutoUpdates) {
				AutoUpdatesTimer = new Timer(async e => await CheckForUpdate().ConfigureAwait(false), null, TimeSpan.FromDays(1), // Delay
					TimeSpan.FromDays(1) // Period
				);

				ArchiLogger.LogGenericInfo("ASF will automatically check for new versions every 24 hours");
			}

			string releaseURL = SharedInfo.GithubReleaseURL;
			if (Program.GlobalConfig.UpdateChannel == GlobalConfig.EUpdateChannel.Stable) {
				releaseURL += "/latest";
			}

			ArchiLogger.LogGenericInfo("Checking new version...");

			GitHub.ReleaseResponse releaseResponse;

			if (Program.GlobalConfig.UpdateChannel == GlobalConfig.EUpdateChannel.Stable) {
				releaseResponse = await Program.WebBrowser.UrlGetToJsonResultRetry<GitHub.ReleaseResponse>(releaseURL).ConfigureAwait(false);
				if (releaseResponse == null) {
					ArchiLogger.LogGenericWarning("Could not check latest version!");
					return;
				}
			} else {
				List<GitHub.ReleaseResponse> releases = await Program.WebBrowser.UrlGetToJsonResultRetry<List<GitHub.ReleaseResponse>>(releaseURL).ConfigureAwait(false);
				if ((releases == null) || (releases.Count == 0)) {
					ArchiLogger.LogGenericWarning("Could not check latest version!");
					return;
				}

				releaseResponse = releases[0];
			}

			if (string.IsNullOrEmpty(releaseResponse.Tag)) {
				ArchiLogger.LogGenericWarning("Could not check latest version!");
				return;
			}

			Version newVersion = new Version(releaseResponse.Tag);

			ArchiLogger.LogGenericInfo("Local version: " + SharedInfo.Version + " | Remote version: " + newVersion);

			if (SharedInfo.Version.CompareTo(newVersion) >= 0) { // If local version is the same or newer than remote version
				return;
			}

			if (!updateOverride && !Program.GlobalConfig.AutoUpdates) {
				ArchiLogger.LogGenericInfo("New version is available!");
				ArchiLogger.LogGenericInfo("Consider updating yourself!");
				await Task.Delay(5000).ConfigureAwait(false);
				return;
			}

			if (File.Exists(oldExeFile)) {
				ArchiLogger.LogGenericWarning("Refusing to proceed with auto update as old " + oldExeFile + " binary could not be removed, please remove it manually");
				return;
			}

			// Auto update logic starts here
			if (releaseResponse.Assets == null) {
				ArchiLogger.LogGenericWarning("Could not proceed with update because that version doesn't include assets!");
				return;
			}

			string exeFileName = Path.GetFileName(exeFile);
			GitHub.ReleaseResponse.Asset binaryAsset = releaseResponse.Assets.FirstOrDefault(asset => !string.IsNullOrEmpty(asset.Name) && asset.Name.Equals(exeFileName, StringComparison.OrdinalIgnoreCase));

			if (binaryAsset == null) {
				ArchiLogger.LogGenericWarning("Could not proceed with update because there is no asset that relates to currently running binary!");
				return;
			}

			if (string.IsNullOrEmpty(binaryAsset.DownloadURL)) {
				ArchiLogger.LogGenericWarning("Could not proceed with update because download URL is empty!");
				return;
			}

			ArchiLogger.LogGenericInfo("Downloading new version...");
			ArchiLogger.LogGenericInfo("While waiting, consider donating if you appreciate the work being done :)");

			byte[] result = await Program.WebBrowser.UrlGetToBytesRetry(binaryAsset.DownloadURL).ConfigureAwait(false);
			if (result == null) {
				return;
			}

			string newExeFile = exeFile + ".new";

			// Firstly we create new exec
			try {
				File.WriteAllBytes(newExeFile, result);
			} catch (Exception e) {
				ArchiLogger.LogGenericException(e);
				return;
			}

			// Now we move current -> old
			try {
				File.Move(exeFile, oldExeFile);
			} catch (Exception e) {
				ArchiLogger.LogGenericException(e);
				try {
					// Cleanup
					File.Delete(newExeFile);
				} catch {
					// Ignored
				}
				return;
			}

			// Now we move new -> current
			try {
				File.Move(newExeFile, exeFile);
			} catch (Exception e) {
				ArchiLogger.LogGenericException(e);
				try {
					// Cleanup
					File.Move(oldExeFile, exeFile);
					File.Delete(newExeFile);
				} catch {
					// Ignored
				}
				return;
			}

			ArchiLogger.LogGenericInfo("Update process finished!");

			if (Program.GlobalConfig.AutoRestart) {
				ArchiLogger.LogGenericInfo("Restarting...");
				await Task.Delay(5000).ConfigureAwait(false);
				Program.Restart();
			} else {
				ArchiLogger.LogGenericInfo("Exiting...");
				await Task.Delay(5000).ConfigureAwait(false);
				Program.Exit();
			}
		}

        private async void MainForm_Load(object sender, EventArgs e)
        {
            Logging.InitFormLogger();

            BotListView.LargeImageList = BotListView.SmallImageList = AvatarImageList;

            await Task.Run(async() => {
                Program.ArchiLogger.LogGenericInfo("ASF V" + SharedInfo.Version);

                if (!Directory.Exists(SharedInfo.ConfigDirectory))
                {
                    Program.ArchiLogger.LogGenericError("Config directory could not be found!");
                    Environment.Exit(1);
                }

                await ASF.CheckForUpdate().ConfigureAwait(false);

                // Before attempting to connect, initialize our list of CMs
                await Bot.InitializeCMs(Program.GlobalDatabase.CellID, Program.GlobalDatabase.ServerListProvider).ConfigureAwait(false);
            });

            foreach (string botName in Directory.EnumerateFiles(SharedInfo.ConfigDirectory, "*.json").Select(Path.GetFileNameWithoutExtension))
            {
                switch (botName)
                {
                case SharedInfo.ASF:
                case "example":
                case "minimal":
                    continue;
                }

                Bot bot = new Bot(botName);

                BotStatusForm botStatusForm = new BotStatusForm(bot);

                BotIndexes[botName] = AvatarImageList.Images.Count;

                AvatarImageList.Images.Add(botName, botStatusForm.AvatarPictureBox.Image);

                botStatusForm.TopLevel = false;
                BotStatusPanel.Controls.Add(botStatusForm);

                ListViewItem botListViewItem = new ListViewItem {
                    ImageIndex = BotIndexes[botName],
                    Text       = botName
                };

                BotListView.Items.Add(botListViewItem);
            }

            if (BotListView.Items.Count > 0)
            {
                BotListView.Items[0].Selected = true;
                BotListView.Select();
            }
        }