Killing a process on exit

Question

My project has an object that creates a process. It this object's Dispose function, it kills the process (or tries to). However, if the program crashes, it leaves the process running and doesn't clean up. Which causes the program to fail next time because it tries to launch the process again and can't get a lock on it.

How can I make sure this process is killed? I always use the object that creates the process in a using block

For reference I'm using C# and .NET 3.5

Answer 1

What kind of program is being launched? It should be possible to launch a second instance even if the first instance is still running - launching the process doesn't lock anything (unless the program itself does something weird).

And how is the object launching the process? If it has a handle to it, it should be able to terminate it instantly by calling the TerminateProcess API.

Here's a really hacky solution to the problem of ensuring a spawned process will die if the caller dies: call DebugActiveProcess, passing the child process ID.

Answer 2

Foo bar = new Foo();
try
{
  bar.DoSomething();
}
catch // if required
{
}
finally
{
  if(bar != null)
  {
    bar.Dispose(); // code from finally clause is ~always executed
  }
}

which is equal to

using(Foo bar = new Foo())
{
  // ..
}

Answer 3

Define "crashes"; there are different levels of crash... for example, if something actively kills your process, you will have very little chance to run any Dispose/finalizers etc - but if your thread unwinds gracefully (even through exception), you should be OK (since you are using using). Can you clarify what the setup is?

Answer 4

What you really want is bi-directional process monitoring so that if either the parent process or the child process dies, you can take appropriate action. The simplest way to do this is to have them ping each other on a timer (every 30 seconds, e.g., you have to tune for your needs) and if no response comes by the time you send the next ping then you can assume the other process has died, locked up, or otherwise stopped playing nice.

If the parent stops responding the child should just exit. If the child stops responding, kill it and start a new one.

How to implement the pinging is left as an exercise for the reader, but any IPC mechanism will do--window messages, RPC calls, pipes... whatever strikes your fancy. Keep it simple; I'm sure .net has something you can use.

Answer 5

I know this will get me yelled at, but how about Enviroment.Exit(). That should kill everything, every time =) It is still better to do the above options though.

Also:

In your Program.cs, before you call Application.Run(Form), do this:

AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);

and then put in a handler that is something like this:

 static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
 {
  try
  {
   String CurrentThreadName = System.Threading.Thread.CurrentThread.Name;

   if (e.IsTerminating)
    Logger.Log("Program", 0, String.Format("Received fatal unhandled exception on '{0}' thread.  Exception will follow.", CurrentThreadName), MsgCategory.Critical, 50);
   else
    Logger.Log("Program", 0, String.Format("Received unhandled exception on '{0}' thread.  Exception will follow.", CurrentThreadName), MsgCategory.Error, 25);

   if (e.ExceptionObject != null)
    Logger.LogException("Program", String.Format("Unhandled System Exception on '{0}' thread.", CurrentThreadName), 50, (Exception)e.ExceptionObject);
  }
  catch
  {
  }
  if (e.IsTerminating)
  {
   Exception ThisException = (Exception)e.ExceptionObject;
   String CurrentThreadName = System.Threading.Thread.CurrentThread.Name;
   MessageBox.Show(
     String.Format(Localization.GetString("fatal_error"), ThisException.GetType().ToString(), ThisException.Message, ThisException.StackTrace, CurrentThreadName)
     , Localization.GetString("dialogtitle")
     , MessageBoxButtons.OK
     , MessageBoxIcon.Error
     , MessageBoxDefaultButton.Button1);
  }
 }

Answer 6

If you want to ensure child process termination, consider creating a separate and simpler watchdog process, watching the process space for termination of either one. It's usually easier to make it bulletproof. There's no way to guarantee the execution of cleanup code in all circumstances.

However, you don't really provide enough context on how your child process is created to permit any relevant advice on how to design the watchdog to be aware of the parent and child processes.