Why is my process not triggering the "Exited" event in a calling process?

I have two .NET Framework 4.8 WPF applications. Let's call them "AppParent" and "AppChild". I cannot actually share the code, but here is the situation.

AppParent is an app that runs other applications, and in this case, is running AppChild. And it does so asynchronously. The way I accomplish this is as follows:

1. My MainView has a Button control, with the Command property bound to a LaunchAppChildCommand.
2. In my MainViewModel, LaunchAppChildCommand is set equal to new AsyncRelayCommand(async () => await ExecuteAsync(AppChild) (I am using Community Toolkit Mvvm NuGet) (also, note that ExecuteAsync actually takes a custom type I created, but what matters is that it includes the fully-qualified file path of AppChild or whatever the process is that I want to run).
3. This is what ExecuteAsync looks like:

        private async Task ExecuteAsync(string appFilePath)
        {
            try
            {
                await Task.Run(async () =>
                {
                    await AsyncUtility.RunConverterAsync(appFilePath);
                });
            }
            catch (Exception ex)
            {
                LogEventViewerLog(ex);
            }
        }

4. I then have a static class, AsyncUtility. AsyncUtility.RunConverterAsync is implemented in this way:

        public static async Task<string> RunConverterAsync(string appFilePath)
        {
            string appSuccessStatus = string.Empty;

            try
            {
                Process process = await RunProcessAsync(appFilePath);

                using (StreamReader streamReader = process.StandardOutput)
                {
                    appSuccessStatus += streamReader.ReadToEnd();

                    if (!appSuccessStatus.Equals("SUCCESS", StringComparison.OrdinalIgnoreCase))
                    {
                        DisplayError(appSuccessStatus); // This just displays a generic error message
                    }
                }
            }
            catch (Exception ex)
            {
                appSuccessStatus += "FAILED";
            }
            return appSuccessStatus;
        }

5. AsyncUtility.RunProcessAsync is a lengthier method:

        private static Task<Process> RunProcessAsync(string fileName)
        {
            TaskCompletionSource<Process> taskCompletionSource = new TaskCompletionSource<Process>();
            string endOfCmdLineArgument = "\" ";

            if (File.Exists(fileName))
            {
                Process process = new Process()
                {
                    StartInfo = new ProcessStartInfo(fileName)
                    {
                        UseShellExecute = false,
                        RedirectStandardOutput = true
                    },
                    EnableRaisingEvents = true
                };

                process.StartInfo.Arguments += "/parameterOne=\"" + StaticClass.ParameterOne + endOfCmdLineArgument
                    + "/parameterTwo=\"" + StaticClass.ParameterTwo + endOfCmdLineArgument;

                Debug.WriteLine(process.StartInfo.Arguments);

                if (process.StartInfo.Arguments.Length > 0)
                {
                    process.StartInfo.Arguments = process.StartInfo.Arguments.Trim();
                }

                process.Exited += (sender, localEventArgs) =>
                {
                    taskCompletionSource.SetResult(process);
                };

                try
                {
                    process.Start();
                }
                catch (Exception ex)
                {
                    throw new InvalidOperationException($"Could not start process: {ex.Message}");
                }
            }
            else
            {
                throw new ArgumentNullException($"The process does not exist:\n{fileName}")
                {
                    Source = "RunProcessAsync"
                };
            }
            return taskCompletionSource.Task;
        }

While the above is not precisely relevant to my problem, the fundamental issue here appears related to processes and threads, which I am spawning from the above code, so I think it is relevant context. (Note that there may be some details in this code that are not entirely consistent or best practice, but this is what ultimately got me a good result.)

Now, the issue actually seems to be occurring in AppChild. When started by process.Start() it'll start going. I've set up my environment to launch the debugger for the AppChild process, and I see confounding behavior. In the App constructor (recall it's also a WPF app) I subscribe to unhandled exceptions like this: AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);. When an exception occurs, I go into my handler:

        private static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
        {
            try
            {
                Exception ex = (Exception)e.ExceptionObject;
                LogEventViewerLog(ex);
            }
            // There is a catch clause here, but it has never been reached during any of my sessions
        }

The debugger goes all the way through, but then back over in AppParent, process.Exited never gets hit! (I have a breakpoint there too, that I know works in some cases.) If I look in my task manager, I see the pesky process for AppChild running and so far I resolve the exited event by terminating that process manually.

The exact exception I am getting that started all this (in AppChild) is System.IO.DirectoryNotFoundException. I started testing by throwing a contrived exception in AppChild: throw new Exception() after my Debugger.Launch(). Lo! The debugger hit my exception handler. The debugger then jumps momentarily back up to my thrown exception and then to the exited event over in AppParent.

Then I went back to testing the original exception (System.IO.DirectoryNotFoundException). I noticed that these methods did not resolve the exited event (i.e. they did not cause the process to end properly): Application.Current.Shutdown(), Application.Current.Dispatcher.InvokeShutdown(), Application.Current.Dispatcher.Invoke(Application.Current.Shutdown). However, the following two did work: Environment.Exit(0) and Process.GetCurrentProcess().Kill(). But these methods are very "abrupt" to my understanding, and can result in other issues. I would think that a process should exit in an appropriate fashion upon an unhandled exception. Am I misunderstanding what the docs mean when they say "In most cases, this means that the unhandled exception causes the application to terminate"?

I then reviewed this article. As I played around with various events, I also tried throwing exceptions around in other places. I then started to notice that the behavior appears related to the point at which the exception occurs in AppChild. As mentioned before, when I throw an exception immediately after Debugger.Launch(), the exited event resolves as expected. The original exception that results in the exited event not triggering comes much later, before I Show() the MainView, but after initializing an IHost instance. Interestingly, when I put my contrived throw new Exception right before the same point that the other exception is being thrown, I see the same behavior. I tried this in various spots, and the relationship seems to hold.

After trying a variety of things, and looking at the documentation I could find, what I am coming up with is that it's related to the IHost - and probably the fact that this is being initiated by AppParent. But I am at a loss as to how to resolve this and perhaps more importantly, why this is happening!

After spending many hours on this, I couldn't figure out why this was occurring. I spent the time to try and replicate the problem in separate solutions, but to no avail. Playing around more with where the Process.Exited event would not be triggered when an unhandled exception was thrown in AppChild, I started to think it was less related to use of IHost and more related to overriding OnStartup. As an alternative, I subscribed to the Application.Startup event which not only worked, but actually has documentation describing its use (compare OnStartup), suggesting that it is recommended. I have also run into other issues before with the use of OnStartup.

I will also add that I altered how the code in ParentApp is starting the Process. First of all, I wasn't disposing of the Process either directly or indirectly. So I wrapped up my Process in a using. Secondly, I was newing up Process twice in my previous code - I am not expertly familiar with the ins and outs of reference types, but my gut was telling me this wasn't a good idea to allocate memory twice. I changed RunProcessAsync to be an extension method, passing in the reference to my object, and thus the operations were affecting the same underlying object. This is what my asynchronous code ended up looking like:

public static async Task<string> RunAppAsync(string appFilePath, string args)
{
	string appSuccessStatus = string.Empty;
	string endOfCmdLineArgument = "\" ";


	if (File.Exists(appFilePath))
	{
		ProcessStartInfo processStartInfo = new ProcessStartInfo
		{
			FileName = appFilePath,
			UseShellExecute = false,
			RedirectStandardOutput = true,
			Arguments = "/debug=\"" + "true" + endOfCmdLineArgument
				+ "/otherParameter=\"" + args + endOfCmdLineArgument
	};


		if (processStartInfo.Arguments.Length > 0)
		{
			processStartInfo.Arguments = processStartInfo.Arguments.Trim();
		}

		using (Process process = new Process {  EnableRaisingEvents = true, StartInfo = processStartInfo })
		{
			await process.RunProcessAsync();

			using (StreamReader streamReader = process.StandardOutput)
			{
				appSuccessStatus += streamReader.ReadToEnd();
				appSuccessStatus = appSuccessStatus.Substring(appSuccessStatus.LastIndexOf('\n') + 1).Trim();

				if (!appSuccessStatus.Equals("SUCCESS", StringComparison.OrdinalIgnoreCase))
				{
					Debug.WriteLine(appSuccessStatus);
					DisplayError(appSuccessStatus);
				}
			}
		}
	}
	else
	{
		throw new ArgumentNullException("The file for this process does not exist.");
	}

	return appSuccessStatus;
}



private static Task<Process> RunProcessAsync(this Process process)
{
	TaskCompletionSource<Process> taskCompletionSource = new TaskCompletionSource<Process>();

	process.Exited += (sender, localEventArgs) =>
	{
		taskCompletionSource.SetResult(process);
	};

	process.Start();

	return taskCompletionSource.Task;
}

So in summary: try subscribing to Startup event instead of overriding OnStartup; make sure to properly dispose of your Process; and be sure that any code dealing with your process (if your situation is similar to mine) is dealing with the same underlying object. These actions seem to have fixed the issue of the Process.Exited event not getting triggered for me.

Other post(s) that might help:

• Why doesn't my process terminate...