Relaunch-Process/Form1.cs

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Threading;
using System.Windows.Forms;
using RelaunchProcess.Properties;
using static System.Windows.Forms.VisualStyles.VisualStyleElement;

namespace Process_Auto_Relaunch
{
    public partial class Form1 : Form
    {
        private delegate void UpdateLogDelegate(string text, bool add_history = false);
        private UpdateLogDelegate updateLogDelegate = null;

        public Form1()
        {
            InitializeComponent();
            this.updateLogDelegate = new UpdateLogDelegate(this.UpdateStatus);
            myBackgroundWorker.WorkerSupportsCancellation = true;
        }

        /// <summary>
        /// Ñîáûòèå çàïóñêà ôîðìû
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Form1_Load(object sender, EventArgs e)
        {
            LoadOldState();


            CheckProgramState();
        }

        /// <summary>
        /// Âîññòàíîâëåíèå íàñòðîåê
        /// </summary>
        private void LoadOldState()
        {
            if (Settings.Default.saveOldState)
            {
                radioButtonEnableWathing.Checked = Settings.Default.enableWatching;
            }
            
        }

        /// <summary>
        /// Ìåòîä äëÿ ñîáûòèÿ îòêëþ÷åíèÿ
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void radioButtonDisableWathing_CheckedChanged(object sender, EventArgs e)
        {
            CheckProgramState();

            if (!radioButtonDisableWathing.Checked)
            {
                return;
            }

            if (myBackgroundWorker.WorkerSupportsCancellation && myBackgroundWorker.IsBusy)
            {
                myBackgroundWorker.CancelAsync();
                UpdateStatus("Îòìåíÿåì...");
            }
        }

        /// <summary>
        /// Ìåòîä äëÿ ñîáûòèÿ âêëþ÷åíèÿ
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void radioButtonEnableWathing_CheckedChanged(object sender, EventArgs e)
        {
            if (!radioButtonEnableWathing.Checked)
            {
                return;
            }
            bool error = false;

            if (String.IsNullOrEmpty(textBoxProcessName.Text))
            {
                error = true;
                MessageBox.Show("Èìÿ ïðîöåññà íå ìîæåò áûòü ïóñòûì!" +
                    "\nÓêàæèòå èìÿ ïðîöåññà", "Îøèáêà", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }

            if (String.IsNullOrEmpty(Settings.Default.startProgramPath))
            {
                error = true;
                MessageBox.Show("Ïðîãðàììà äëÿ çàïóñêà íå óêàçàíà." +
                    "\nÓêàæèòå ïðîãðàììó äëÿ çàïóñêà", "Îøèáêà", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }

            if (error)
            {
                radioButtonEnableWathing.Checked = false;
                radioButtonDisableWathing.Checked = true;
                return;
            }

            if (!myBackgroundWorker.IsBusy)
            {
                myBackgroundWorker.RunWorkerAsync();
            }
        }

        /// <summary>
        /// Îáíîâëåíèå ñòàòóñà â ïðîãðàììå
        /// </summary>
        /// <param name="text">Òåêñò äëÿ îòîáðàæåíèÿ</param>
        /// <param name="add_history">Ñîõðàíåíèå òåêñòà â îêíî èñòîðèè</param>
        public void UpdateStatus(string text, bool add_history = false)
        {
            labelStatus.Text = text;

            if (add_history)
            {
                HistoryLog(text);
            }
        }

        private void HistoryLog(string text)
        {
            richTextBoxHistory.Text += DateTime.Now.ToString() + ": " + text + "\n";
        }

        public void Status(string text, bool add_history = false)
        {
            Invoke(updateLogDelegate, text, add_history);
        }

        private void CheckProgramState()
        {
            bool watching = radioButtonEnableWathing.Checked;
            Debug.WriteLine($"Íàáëþäåíèå: {watching}");

            groupBoxProcessName.Enabled = !watching;
            groupBoxProgramStart.Enabled = !watching;
            groupBoxActions.Enabled = !watching;

            Settings.Default.enableWatching = watching;

            
        }

        /// <summary>
        /// Âûáîð ôàéëà äëÿ çàïóñêà
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void buttonSetProgramStart_Click(object sender, EventArgs e)
        {
            OpenFileDialog openFile = new OpenFileDialog();
            openFile.Title = "Óêàæèòå ïðîãðàììó çàïóñêà";

            if (openFile.ShowDialog() == DialogResult.Cancel)
            {
                return;
            }

            //labelProgramStartPath.Text = openFile.FileName;
            Settings.Default.startProgramPath = openFile.FileName;
            Settings.Default.Save();

            openFile.Dispose();
        }

        /// <summary>
        /// Ñîáûòèå ïåðåä çàêðûòèåì ôîðìû
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            Settings.Default.Save();
        }

        private bool ProcessByNameIsRuning(string name)
        {
            return Process.GetProcessesByName(name).Length > 0;
        }

        private void ProcessStart(string path, string args)
        {
            if (checkBoxCheckProcess.Checked)
            {
                if (ProcessByNameIsRuning(path))
                {
                    return;
                }
            }

            Status("Ïðîöåññ áûë çàïóùåí.", true);
            Process.Start(path, args);
        }

        private void BackgroundWorkerDoWork(object sender, System.ComponentModel.DoWorkEventArgs e)
        {
            BackgroundWorker worker = sender as BackgroundWorker;
            int i = (int)numericUpDown1.Value;

            while (!worker.CancellationPending)
            {
                if (ProcessByNameIsRuning(textBoxProcessName.Text))
                {
                    Status($"Ïðîöåññ {textBoxProcessName.Text} óæå çàïóùåí");
                    i = (int)numericUpDown1.Value;
                }
                else
                {
                    if (radioButtonRestartTimer.Checked)
                    {
                        i--;
                        Status($"Ïðîöåññ {textBoxProcessName.Text} íå íàéäåí. Çàïóñê ÷åðåç {i}");
                    }

                    if (i <= 0 || radioButtonRestartNow.Checked)
                    {
                        i = (int)numericUpDown1.Value;
                        Status("Çàïóñêàåì...");
                        ProcessStart(Settings.Default.startProgramPath, textBoxArguments.Text);
                    }
                }

                Thread.Sleep(1000);
            }

            if (worker.CancellationPending)
            {
                e.Cancel = true;
            }
        }

        private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            if (e.Cancelled)
            {
                Status("Íàáëþäåíèå îòìåíåíî.");
            }
            else if (e.Error != null)
            {
                MessageBox.Show("Error: " + e.Error.Message, "Îøèáêà", MessageBoxButtons.OK, MessageBoxIcon.Stop);
                Status("Ïðîèçîøëà îøèáêà! Íàáëþäåíèå îñòàíîâëåíî.", true);
                radioButtonDisableWathing.Checked = true;
            }
            else
            {
                Status("Íàáëþäåíèå îñòàíîâëåíî.");
            }
        }
    }
}