How to create a Process that outlives its parent

I'm trying to launch an external updater application for a platform that I've developed. The reason I'd like to launch this updater is because my configuration utility which handles updates and license configuration for the platform has shared dependencies with other assemblies in the folder where the update will be deployed. So, while I can rename the configuration utility and overwrite it when deploying the update, I can't rename or overwrite the DLLs it depends on. Hence, the external updater application.

I'm handling all of the update gathering logic in the configuration utility, then attempting to launch the updater to handle the actual file copy/overwrite operations. Obviously, because of the file in use issues, I need the configuration utility to exit right after the updater begins.

The problem I'm having is that I'm using the standard Process.Start method of launching the updater, and as soon as the configuration utility exits, the updater process gets killed too.

Is there any way that I can create a Process that outlives its parent, or launch an external application that can run beyond the program that launched it?

EDIT:

Apparently, in my updater application, I miscalculated the number of command line arguments which are passed to it. Because of this, the updater would exit immediately. I misinterpreted this to mean that the launcher application was killing the "child" process, when in fact, it wasn't.

The answers below are correct.

Solution 1:

It seems that the problem you are seeing has a different reason because the Process class will not kill any processes started using Process.Start when your application exits.

See this simple sample program, the calculator will stay open:

using System.Diagnostics;

class Program
{
    static void Main(string[] args)
    {
        Process.Start(@"C:\windows\system32\calc.exe");
    }
}

Solution 2:

There's no reason why a process started with Process.Start should automatically die when the launcher exits. My guess is that you're doing something odd in the updater.

I've written an updater doing exactly this kind of thing before, and it's been fine.

For example:

Launcher.cs:

using System;
using System.Diagnostics;

class Launcher
{
    static void Main()
    {
        Console.WriteLine("Launching launchee");
        Process.Start("Launchee.exe");
        Console.WriteLine("Launched. Exiting");
    }
}

Launchee.cs:

using System;
using System.Threading;

class Launchee
{
    static void Main()
    {
        Console.WriteLine("       I've been launched!");
        Thread.Sleep(5000);
        Console.WriteLine("       Exiting...");
    }
}

Compile both of them, separately, and run Launcher.exe. The "launchee" process definitely lasts longer than the launcher.