Existe uma maneira de certificar-se de um processo de fundo gerado por meu programa é morto quando meus processo termina?
-
08-07-2019 - |
Pergunta
Basicamente, o processo filho é executado indefinidamente até morto no fundo, e eu quero limpá-lo quando meus termina programa, por qualquer motivo, ou seja, através da Taskmanager.
Atualmente tenho um tempo (Process.GetProcessesByName ( "ParentProcess"). Count ()> 0) loop e sair se o processo pai não está em execução, mas parece bastante frágil, e se eu queria trabalhar sob depurador no Visual Studio eu teria que adicionar "ParentProcess.vshost" ou algo assim.
Existe alguma maneira para se certificar de que o fim processo filho sem exigir que o processo filho para saber sobre o processo pai? Eu prefiro uma solução em código gerenciado, mas se não há um eu posso PInvoke.
Edit: Passando o PID parece ser uma solução mais robusta, mas por curiosidade, e se o processo filho não era meu código, mas alguns exe que eu não tenho controle sobre? Existe uma maneira de salvaguarda contra possivelmente criando processos filho órfãos?
Solução
Se o processo filho é o seu próprio código, você poderia passá-lo o PID do processo-pai quando você iniciá-lo. O processo filho poderia, então, buscar o processo com Process.GetProcessById
e assinar o seu evento Exited
com um manipulador que desliga o resto do processo (criança) graciosamente. Note que você precisa para definir o EnableRaisingEvents
propriedade sobre o processo de true
.
Outras dicas
Se o processo filho não é seu próprio código que você pode usar este código para encontrar e matar todos os processos filhos:
using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Runtime.InteropServices;
namespace Util {
public static class ProcessExtensions {
public static void KillDescendants(this Process processToNotKillYet) {
foreach (var eachProcess in Process.GetProcesses()) {
if (eachProcess.ParentPid() == processToNotKillYet.Id) {
eachProcess.KillTree();
}
}
}
public static void KillTree(this Process processToKill) {
processToKill.KillDescendants();
processToKill.Kill();
}
public static PROCESS_BASIC_INFORMATION Info(this Process process) {
var processInfo = new PROCESS_BASIC_INFORMATION();
try {
uint bytesWritten;
NtQueryInformationProcess(process.Handle,
0,
ref processInfo,
(uint)Marshal.SizeOf(processInfo),
out bytesWritten); // == 0 is OK
}
catch (Win32Exception e) {
if (!e.Message.Equals("Access is denied")) throw;
}
return processInfo;
}
public static int ParentPid(this Process process) {
return process.Info().ParentPid;
}
[DllImport("ntdll.dll")]
private static extern int NtQueryInformationProcess(
IntPtr hProcess,
int processInformationClass /* 0 */,
ref PROCESS_BASIC_INFORMATION processBasicInformation,
uint processInformationLength,
out uint returnLength);
[StructLayout(LayoutKind.Sequential)]
public struct PROCESS_BASIC_INFORMATION {
public int ExitStatus;
public int PebBaseAddress;
public int AffinityMask;
public int BasePriority;
public int Pid;
public int ParentPid;
}
}
}
O termo comum para esse processo filho um em como órfão processo . Veja o artigo ligado para algumas soluções possíveis.
Aqui um código-fonte para um pequeno utilitário aplicativo eu construí (É baseado na solução Alan Hensel, o que eu achei muito útil).
É chamado ChildrenProcessKiller e é um observador que permite matar todos os descendentes processo de um determinado processo pai quando sai do processo pai (mesmo que o processo pai trava)
Uso:
ChildrenProcessKiller.exe parentProcessId
Aviso: este código é fornecido "como está", e pode matar bebês pequenos ;-)
ChildrenProcessKiller.cs
using System;
using System.Collections.Generic;
using System.Diagnostics;
namespace ChildrenProcessKiller
{
static class ChildrenProcessKiller
{
[STAThread]
static void Main(string[] args)
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
string message = "This is a watcher that enables to kill all descendants process of a given parent process\n";
message += "when the parent process exits (even if the parent process crashes) \n\n";
message += "Usage : " + Application.ExecutablePath + " parentProcessId";
if (args.Length != 1)
{
MessageBox.Show(message);
System.Environment.Exit(1);
}
int parentProcessId;
if (!Int32.TryParse(args[0], out parentProcessId))
{
MessageBox.Show(message);
System.Environment.Exit(1);
}
try
{
mParentProcess = Process.GetProcessById(parentProcessId);
}
catch (System.ArgumentException ex)
{
//Parent process cannot be found!
System.Environment.Exit(2);
}
Run();
}
private static List<Process> mChildrenProcesses;
private static Process mParentProcess;
private static void Run()
{
int thisProcessId = Process.GetCurrentProcess().Id;
while ( ! mParentProcess.HasExited )
{
RefreshChildrenProcesses();
System.Threading.Thread.Sleep(1000);
}
foreach (Process childProcess in mChildrenProcesses)
{
if ((!childProcess.HasExited) && (childProcess.Id != thisProcessId))
{
KillGracefullyThenViolently(childProcess);
}
}
}
private static void KillGracefullyThenViolently(Process process)
{
if (process.HasExited)
return;
try
{
process.CloseMainWindow();
}
catch (PlatformNotSupportedException)
{}
catch (InvalidOperationException)
{}//do nothing : this app is meant to be "unstoppable", unless the parent process has exited
for (int i = 0; i < 15; i++)
{
System.Threading.Thread.Sleep(100);
if (process.HasExited)
return;
}
try
{
process.Kill();
}
catch (System.ComponentModel.Win32Exception)
{}
catch(NotSupportedException)
{}
catch(InvalidOperationException)
{} //same comment here
}
private static void RefreshChildrenProcesses()
{
if (mParentProcess.HasExited)
return;
List<Process> newChildren;
try
{
newChildren = Utils.ProcessTree.GetProcessDescendants(mParentProcess);
mChildrenProcesses = newChildren;
}
catch (System.Exception ex)
{
;
}
}
}
}
ProcessTree.cs
using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Collections.Generic;
using System.IO;
using System.Windows.Forms;
namespace Utils
{
public static class ProcessTree
{
public static List<Process> GetProcessDescendants(Process process)
{
List<Process> result = new List<Process>();
foreach (Process eachProcess in Process.GetProcesses())
{
if (ParentPid(eachProcess) == process.Id)
{
result.Add(eachProcess);
}
}
return result;
}
public static void KillDescendants(Process processToNotKillYet)
{
foreach (Process eachProcess in Process.GetProcesses())
{
if (ParentPid(eachProcess) == processToNotKillYet.Id)
{
if (eachProcess.Id != Process.GetCurrentProcess().Id)
KillTree(eachProcess);
}
}
}
public static void KillTree(Process processToKill)
{
KillDescendants(processToKill);
processToKill.Kill();
}
public static PROCESS_BASIC_INFORMATION Info(Process process)
{
PROCESS_BASIC_INFORMATION processInfo = new PROCESS_BASIC_INFORMATION();
try
{
uint bytesWritten;
NtQueryInformationProcess(process.Handle,
0,
ref processInfo,
(uint)Marshal.SizeOf(processInfo),
out bytesWritten); // == 0 is OK
}
catch (Win32Exception e)
{
if (!e.Message.Equals("Access is denied")) throw;
}
return processInfo;
}
public static int ParentPid(Process process)
{
return Info(process).ParentPid;
}
[DllImport("ntdll.dll")]
private static extern int NtQueryInformationProcess(
IntPtr hProcess,
int processInformationClass /* 0 */,
ref PROCESS_BASIC_INFORMATION processBasicInformation,
uint processInformationLength,
out uint returnLength);
[StructLayout(LayoutKind.Sequential)]
public struct PROCESS_BASIC_INFORMATION
{
public int ExitStatus;
public int PebBaseAddress;
public int AffinityMask;
public int BasePriority;
public int Pid;
public int ParentPid;
}
}
}
Passe o ID de processo pai como parâmetro de linha de comando para processo filho.
No processo filho de uso Processar get por id e subscrevê-lo do evento Sair ou criar uma linha e chamada para Process.WaitForExit