Closing a Process that was started via a thread

Question

I am currently working on a c# project and am using the System.Diagnostic.Process class.

When my program starts it creates a new thread and within each thread starts a different process.

At some point I need to check a setting within my program to see whether each process should continue running or whether it should be stopped but I have no idea how I can reference the process that was started by a certain thread. Each thread I have given a name when the process started but my understanding is c# creates the thread, starts the process and then closes the thread even if the process is still running and is still receiving output.

Is there a way I can find out which process was started by which thread and cancel that processs from running.

But I can't see how I can use this method and the dictionary to be able to stop the process based on this thread name.

UPDATE As request below is the code that I am using that creates each process in the thread. I am using the thread in a dictionary so that I can references it from the outputreceived event but not sure how to do it if I need to close the process.

Thread worker = new Thread(new ThreadStart(() => startProducts(product.Value[0].startScript, product.Value[0].productName)));
                worker.IsBackground = false;
                worker.Name = product.Value[0].productName;
                worker.Start();
                logging.logger(string.Format("Starting product '{0}'", product.Value[0].productName));

The method that the thread calls is as follows, this is where each process is started. Each process is guaranteed to have a different named thread, there will never be two threads with the same name.

private void startProducts(string startScript, string product)
        {
            Process startProductProcess = new Process();
            startProductProcess.StartInfo.FileName = startScript;
            if ( configManagement.productConfig[product][0].requireArguments == true )
            {
                startProductProcess.StartInfo.Arguments = configManagement.productConfig[product][0].arguments;
            }
            startProductProcess.StartInfo.UseShellExecute = false;
            startProductProcess.StartInfo.RedirectStandardOutput = true;
            StringBuilder processOutput = new StringBuilder("");
            startProductProcess.OutputDataReceived += new DataReceivedEventHandler(startProductProcess_OutputDataReceived);
            startProductProcess.Exited += new EventHandler(startProductProcess_Exited);
            processTag.Add(startProductProcess, product);
            startProductProcess.Start();
            //Process localByName = Process.GetProcessById(startProductProcess.Id);
            startProductProcess.BeginOutputReadLine();
            logging.logger(string.Format("Started {0} with: {1} {2}", product, 
                startProductProcess.StartInfo.FileName, startProductProcess.StartInfo.Arguments));
        }

Answer 1

Why use the thread name for anything? If you were to pool this activity off, you wold have no idea which thread was going to run any particular process.

If you are managing processes, define a 'managedProcess' class that can contain fields and properties for the process name, process EXE path, process handle, the thread waiting on the handle for the process to finish, any status enum, any mutex to keep the fields thread-safe, methods to start it and stop it - anything to do with the process. Shove instances of this managedProcess class into your container.

IMHO, forget thread names for anything except debugging.

Terminating - in your stop() method, you can try posting a WM_CLOSE, (can you do that directly, or is it a P/Invoke?), waiting for some seconds to see if the thread waiting signals that the process has closed and, if not, call TerminateProcess(), (or whatever the managed thingy is for TerminateProcess).

Answer 2

Unless you have a specific need that is solved by creating each process using a separate thread, don't use threads. If all you are looking for is a unique way to identify a given process in your code, you can use the name that you were giving to the thread as an identifier in your dictionary.

Dictionary<string, Process> processesByName = new Dictionary<string, Process>();
Process firstProcess = ... //Start your process
Process secondProcess = ... //Start your process
processesByName.Add("FirstProcessName", firstProcess);
processesByName.Add("SecondProcessName", secondProcess);

After that, you can just pull a given process by the name you've assigned and interact with it however you want.

Process process = processesByName["FirstProcessName"];
if (!process.HasExited)
{
    process.CloseMainWindow();
    process.Close();
}