Tuer l'arbre du processus de manière programmatique en C#

vous devez appeler Process.CloseMainWindow() qui enverra un message à la fenêtre principale du processus. Pensez - y comme si l'utilisateur avait cliqué sur le bouton "X" Fermer ou fichier | sortie élément de menu.

il est plus sûr d'envoyer un message à Internet Explorer pour se fermer, que d'aller tuer tous ses processus. Ces processus peuvent faire n'importe quoi et vous devez laisser IE faire son truc et finir avant de le tuer dans le au milieu de faire quelque chose qui pourrait être important pour les futures courses. Cela vaut pour tout programme que vous tuez.

Je ne suis fan d'aucune des solutions présentées ici.

voici ce que j'ai trouvé:

private static void EndProcessTree(string imageName)
{
    Process.Start(new ProcessStartInfo
    {
        FileName = "taskkill",
        Arguments = $"/im {imageName} /f /t",
        CreateNoWindow = true,
        UseShellExecute = false
    }).WaitForExit();
}

comment utiliser:

EndProcessTree("chrome.exe");

• Classe De Processus (Système D'.Diagnostics)
• ProcessStartInfo Classe (Système D'.Diagnostics)
• Taskkill

Si quelqu'un est intéressé, j'ai pris l'une des réponses de l'autre page et la modifier légèrement. C'est une classe avec des méthodes statiques. Il ne pas avoir la manipulation d'erreur appropriée ou la journalisation. Modifier pour l'utiliser pour vos propres besoins. Fournir votre processus root pour KillProcessTree le fera.

class ProcessUtilities
{
    public static void KillProcessTree(Process root)
    {
        if (root != null)
        {
            var list = new List<Process>();
            GetProcessAndChildren(Process.GetProcesses(), root, list, 1);

            foreach (Process p in list)
            {
                try
                {
                    p.Kill();
                }
                catch (Exception ex)
                {
                    //Log error?
                }
            }
        }
    }

    private static int GetParentProcessId(Process p)
    {
        int parentId = 0;
        try
        {
            ManagementObject mo = new ManagementObject("win32_process.handle='" + p.Id + "'");
            mo.Get();
            parentId = Convert.ToInt32(mo["ParentProcessId"]);
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.ToString());
            parentId = 0;
        }
        return parentId;
    }

    private static void GetProcessAndChildren(Process[] plist, Process parent, List<Process> output, int indent)
    {
        foreach (Process p in plist)
        {
            if (GetParentProcessId(p) == parent.Id)
            {
                GetProcessAndChildren(plist, p, output, indent + 1);
            }
        }
        output.Add(parent);
    }
}

une autre solution consiste à utiliser la commande taskill. J'utilise le code suivant dans mes applications:

public static void Kill()
{
    try
    {
            ProcessStartInfo processStartInfo = new ProcessStartInfo("taskkill", "/F /T /IM your_parent_process_to_kill.exe")
            {
                WindowStyle = ProcessWindowStyle.Hidden,
                CreateNoWindow = true,
                UseShellExecute = false,
                WorkingDirectory = System.AppDomain.CurrentDomain.BaseDirectory,
                RedirectStandardOutput = true,
                RedirectStandardError = true
            };
            Process.Start(processStartInfo);
    }
    catch { }
}

si quelqu'un a besoin d'une solution dotnet core, dotnet cli a développé une implémentation basée sur taskill comme mentionné ci-dessus et récursive pgrep/kill pour les systèmes basés sur unix. la Pleine mise en œuvre peut être trouvé sur github . Malheureusement, la classe est interne donc vous devrez la Copier dans votre base de code.

Liste des processus Enfants (doit être fait de manière récursive):

$"pgrep -P {parentId}"

Tuer sur le processus:

$"kill -TERM {processId}"

utilisez-vous IE8 ou IE9? Cela lancerait absolument plus d'un processus en raison de sa nouvelle architecture multi-processus. Quoi qu'il en soit, jetez un oeil à cette autre réponse pour obtenir un arbre de processus et le tuer.

une autre approche qui peut être très utile est d'utiliser L'API de Windows pour les objets de travail . Un processus peut être attribué à un objet de travail. Les processus enfants d'un tel processus sont automatiquement attribués à la même objet de travail.

tous les processus assignés à un objet de travail peuvent être tués à la fois, p.ex. avec Terminatejobject qui:

met fin à tous les processus actuellement associés à emploi.

le c# exemple dans cette réponse ( basé sur cette réponse ) utilise le JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE drapeau à la place, qui:

provoque la fin de tous les processus associés à l'emploi lorsque la dernière poignée vers l'emploi est fermée.

comment fermer correctement Internet Explorer lorsqu'il est lancé depuis PowerShell?

plusieurs de ceux qui ont commenté dans le thread ci-dessus que cela est causé par un bug dans Win7 (comme il ne semble pas se produire pour les utilisateurs qui utilisent d'autres versions de windows). Beaucoup de pages sur l'internet, y compris la page de microsoft revendication d'erreur de l'utilisateur, et vous dire d'utiliser simplement la méthode quit disponible sur L'objet IE qui est censé fermer tous les processus enfant comme bien (et, apparemment, n'en Win8/XP etc)

je dois admettre, pour ma part, que c'était une erreur de l'utilisateur. Je suis dans win7 et la raison pour laquelle la méthode d'abandon ne fonctionnait pas pour moi était en raison d'une erreur de codage. Plus précisément, je créais L'objet IE lors de la déclaration, puis j'en créais un autre (attaché au même objet) plus tard dans le code... J'avais presque fini de pirater la routine parent-enfant de tuer pour travailler pour moi quand j'ai réalisé le problème.

à cause de comment IE functions, le processID que vous avez généré comme parent peut être attaché à d'autres fenêtres/sous-processus que vous n'avez pas créés. Utilisez quit, et gardez à l'esprit que selon les paramètres de l'utilisateur (comme le cache vide à la sortie), les processus peuvent prendre quelques minutes pour terminer leurs tâches et fermer.