Pb pour Killer un process

**mr100kv** · 05/10/2012, 16h37

Bonjour,

Je suis en train de développer un utilitaire visant à killer une application métier qui serait plantée.
Le souci, est que si cette application est lancée, je ne peux arrêter aucune application quelle qu'elle soit, y/c celle que je suis censé killer.
Si ladite application (dev en c#) n'est pas lancée, alors je peus killer toutes les autres applications sans souci.
Je n'arrive pas à comprendre ce qui bloque mon prog.
Pour info, si je passe par un gestionnaire de tâches, pas de souci, je peux bien supprimer l'appli métier en question ; cependant, l'utilisateur n'a pas accès au gestionnaire des tâches, d'ou mon utlitaire...
Ci joint plus bas mon bout de code.
Le pb se situe au niveau de :
IntPtr intptrSnapshot_ = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
qui me renvoie -1 si l'appli métier est lancée (ce qui me pose pb car il y a bien des tas de process lancés, et donc la valeur devrait être différente de -1), et une autre valeur si elle ne l'est pas.
Pour le code, je n'ai pas la prétention de l'avoir pondu, je remercie celui qui l'a fait pour nous et qui l'a mis à disposition des autres...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
        public static List<ProcEntry> list_ = null;
 
        public class ProcEntry
        {
            public string ExeName;
            public uint ID;
        }
 
        public class ProcessEnumeratorOutil
        {
            #region Constantes
                private const uint TH32CS_SNAPPROCESS = 0x00000002;
                private const int MAX_PATH = 260;
            #endregion
 
            #region Structures
            public struct PROCESSENTRY
            {
                public uint dwSize;
                public uint cntUsage;
                public uint th32ProcessID;
                public uint th32DefaultHeapID;
                public uint th32ModuleID;
                public uint cntThreads;
                public uint th32ParentProcessID;
                public int pcPriClassBase;
                public uint dwFlags;
                [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH)]
                public string szExeFile;
                uint th32MemoryBase;
                uint th32AccessKey;
            }
            #endregion
 
            #region P/Invoke
            [DllImport("toolhelp.dll")]
            private static extern IntPtr CreateToolhelp32Snapshot(uint flags, uint processID);
 
            [DllImport("toolhelp.dll")]
            private static extern int CloseToolhelp32Snapshot(IntPtr snapshot);
 
            // Cette fonction permet de demander le premier processus provenant de la liste contenu dans une photo du système d'exploitation
            [DllImport("toolhelp.dll")]
            private static extern int Process32First(IntPtr snapshot, ref PROCESSENTRY processEntry);
 
            // Cette fonction permet de demander le processus suivant provenant de la liste contenu dans une photo du système d'exploitation
            [DllImport("toolhelp.dll")]
            private static extern int Process32Next(IntPtr snapshot, ref PROCESSENTRY processEntry);
            #endregion
 
            #region public Methods
            /// <summary>
            /// Fonction énumérant la liste des process en cours d'utilisation
            /// </summary>
            /// <param name="list">Indiquer le type de liste que l'on désire envoyer en paramètre : ici " ProcEntry "</param>
            /// <returns></returns>
            public static bool Enumerate(ref List<ProcEntry> list)
            {
                if (list == null)
                {
                    return false;
                }
                list.Clear();
 
                IntPtr intptrSnapshot_ = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
                if (intptrSnapshot_ == IntPtr.Zero)
                {
                    return false;
                }
 
                PROCESSENTRY peEntry_ = new PROCESSENTRY();
                peEntry_.dwSize = (uint)Marshal.SizeOf(peEntry_);
                if (Process32First(intptrSnapshot_, ref peEntry_) == 0)
                {
                    CloseToolhelp32Snapshot(intptrSnapshot_);
                    return false;
                }
 
                do
                {
                    ProcEntry procEntry = new ProcEntry();
                    procEntry.ExeName = peEntry_.szExeFile;
                    procEntry.ID = peEntry_.th32ProcessID;
                    list.Add(procEntry);
                    peEntry_.dwSize = (uint)Marshal.SizeOf(peEntry_);
                }
                while (Process32Next(intptrSnapshot_, ref peEntry_) != 0);
 
                CloseToolhelp32Snapshot(intptrSnapshot_);
 
                return true;
            }
            #endregion
 
        }
 
        /// <summary>
        /// Kill le process indiqué en argument
        /// </summary>
        public static void CtrlProcess(string ProcessName, string strAppName)
        {
            // Instanciation de la nouvelle liste
            list_ = new List<ProcEntry>();
 
            // on essaie de killer le process s'il existe...
            try
            {
                int intCpt = 0;
 
                if (ProcessEnumeratorOutil.Enumerate(ref list_))
                {
                    for (int i = 0; i < list_.Count; i++)
                    {
                        if (list_[i].ExeName.ToLower() == ProcessName.ToLower())
                        {
                            Process myProcess = Process.GetProcessById((int)(list_[i].ID));
                            myProcess.Kill();
                            // Affichage d'un msgBox de succès
                            MessageBox.Show(string.Format("L'application {0} est maintenant fermée", strAppName), string.Format("Fermeture de {0}",strAppName), MessageBoxButtons.OK, MessageBoxIcon.Asterisk, MessageBoxDefaultButton.Button1);
                            intCpt = 1;
                        }
                    }
                }
                // ... si le process n'est pas trouvé (l'application n'est pas lancée), on prévient l'utilisateur
                if (intCpt == 0)
                {
                    MessageBox.Show(string.Format("L'application {0} n'est pas en cours d'exécution.", strAppName));
                }
            }
 
            // ...sinon on alerte l'utilisateur qu'un bug est survenu
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }

Je vous remercie d'avance pour votre aide précieuse,

**synolog** · 09/10/2012, 09h45

Salut!

Pour tuer mes appli métier j'utilise cette méthode qui fonctionne très bien!

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
        private static void Kill(string proc, string mess)
        {
            Process[] killProc;
            killProc = Process.GetProcessesByName(proc);
            Console.WriteLine("* Fermeture "+ mess +"...");
            foreach (Process mykillProc in killProc)
            {
                mykillProc.Kill();
                mykillProc.WaitForExit(5000);
            }
        }

Si cela peut t'aidé, car pour tué un prog quelques lignes suffisent...