ProcessManager.cs

//--------------------------------------------------//
// Created by basicx-StrgV                          //
// https://github.com/basicx-StrgV/                 //
//--------------------------------------------------//
using System.Diagnostics;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using WGetNET.Extensions;
using WGetNET.Models;
 
namespace WGetNET.Components.Internal
{
    internal class ProcessManager
    {
        private readonly ProcessStartInfo _winGetStartInfoTemplate;
 
        public ProcessManager(string processName)
        {
            _winGetStartInfoTemplate = new ProcessStartInfo()
            {
                CreateNoWindow = true,
                FileName = processName,
                UseShellExecute = false,
                RedirectStandardOutput = true,
                StandardOutputEncoding = Encoding.UTF8
            };
        }
 
        public ProcessResult ExecuteWingetProcess(string cmd)
        {
            return RunProcess(GetStartInfo(cmd));
        }
 
        public async Task<ProcessResult> ExecuteWingetProcessAsync(string cmd, CancellationToken cancellationToken = default)
        {
            return await RunProcessAsync(GetStartInfo(cmd), cancellationToken);
        }
 
        private ProcessStartInfo GetStartInfo(string cmd)
        {
            return new ProcessStartInfo()
            {
                CreateNoWindow = _winGetStartInfoTemplate.CreateNoWindow,
                FileName = _winGetStartInfoTemplate.FileName,
                RedirectStandardOutput = _winGetStartInfoTemplate.RedirectStandardOutput,
                StandardOutputEncoding = _winGetStartInfoTemplate.StandardOutputEncoding,
                UseShellExecute = _winGetStartInfoTemplate.UseShellExecute,
                WindowStyle = _winGetStartInfoTemplate.WindowStyle,
                Arguments = cmd
            };
        }
 
        private ProcessResult RunProcess(ProcessStartInfo processStartInfo)
        {
            ProcessResult result = new();
 
            //Create and run process
            using (Process proc = new() { StartInfo = processStartInfo })
            {
                proc.Start();
 
                result.Output = proc.StandardOutput.ReadSreamOutputByLine();
 
                //Wait till end and get exit code
                proc.WaitForExit();
 
                // Make sure the process has exited
                if (!proc.HasExited)
                {
                    proc.Kill();
                }
 
                result.ExitCode = proc.ExitCode;
            }
 
            return result;
        }
 
        private async Task<ProcessResult> RunProcessAsync(ProcessStartInfo processStartInfo, CancellationToken cancellationToken = default)
        {
            ProcessResult result = new();
 
            //Create and run process
            using (Process proc = new() { StartInfo = processStartInfo })
            {
                proc.Start();
 
                result.Output = await proc.StandardOutput.ReadSreamOutputByLineAsync(cancellationToken);
 
                // Kill the process and return, if the task is canceled
                if (cancellationToken.IsCancellationRequested && !proc.HasExited)
                {
                    proc.Kill();
 
                    result.ExitCode = -1;
 
                    return result;
                }
 
                //Wait for the processs to exit
                proc.WaitForExit();
 
                // Make sure the process has exited
                if (!proc.HasExited)
                {
                    proc.Kill();
                }
 
                result.ExitCode = proc.ExitCode;
            }
 
            return result;
        }
    }
}