1 using System; 2 using System.Collections.Generic; 3 using System.Runtime.InteropServices; 4 using System.Text; 5 using System.ComponentModel; 6 7 namespace Upgrade 8 { 9 /// <summary> 10 /// Contains information about a process. 11 /// This information is collected by ProcessCE.GetProcesses(). 12 /// </summary> 13 public class ProcessInfo 14 { 15 [DllImport("coredll.dll", SetLastError = true)] 16 private static extern int GetModuleFileName(IntPtr hModule, StringBuilder lpFilename, int nSize); 17 18 private const int INVALID_HANDLE_VALUE = -1; 19 20 private IntPtr _pid; 21 private int _threadCount; 22 private int _baseAddress; 23 private int _parentProcessID; 24 private string _fullPath; 25 26 internal ProcessInfo(IntPtr pid, int threadcount, int baseaddress, int parentid) 27 { 28 _pid = pid; 29 _threadCount = threadcount; 30 _baseAddress = baseaddress; 31 _parentProcessID = parentid; 32 33 StringBuilder sb = new StringBuilder(1024); 34 GetModuleFileName(_pid, sb, sb.Capacity); 35 _fullPath = sb.ToString(); 36 } 37 38 /// <summary> 39 /// Returns the full path to the process .EXE file. 40 /// </summary> 41 /// <example>"\Program Files\Acme\main.exe"</example> 42 public override string ToString() 43 { 44 return _fullPath; 45 } 46 47 public int BaseAddress 48 { 49 get { return _baseAddress; } 50 } 51 52 public int ThreadCount 53 { 54 get { return _threadCount; } 55 } 56 57 /// <summary> 58 /// Returns the Process Id. 59 /// </summary> 60 public IntPtr Pid 61 { 62 get { return _pid; } 63 } 64 65 /// <summary> 66 /// Returns the full path to the process .EXE file. 67 /// </summary> 68 /// <example>"\Program Files\Acme\main.exe"</example> 69 public string FullPath 70 { 71 get { return _fullPath; } 72 } 73 74 public int ParentProcessID 75 { 76 get { return _parentProcessID; } 77 } 78 79 /// <summary> 80 /// Kills the process. 81 /// </summary> 82 /// <exception cref="Win32Exception">Thrown when killing the process fails.</exception> 83 public void Kill() 84 { 85 ProcessCE.Kill(_pid); 86 } 87 88 } 89 90 /// <summary> 91 /// Static class that provides Windows CE process information and manipulation. 92 /// The biggest difference with the Compact Framework's Process class is that this 93 /// class works with the full path to the .EXE file. And not the pathless .EXE file name. 94 /// </summary> 95 public static class ProcessCE 96 { 97 private const int MAX_PATH = 260; 98 private const int TH32CS_SNAPPROCESS = 0x00000002; 99 private const int TH32CS_SNAPNOHEAPS = 0x40000000; 100 private const int INVALID_HANDLE_VALUE = -1; 101 private const int PROCESS_TERMINATE = 1; 102 103 /// <summary> 104 /// Returns an array with information about running processes. 105 /// </summary> 106 ///<exception cref="Win32Exception">Thrown when enumerating the processes fails.</exception> 107 public static ProcessInfo[] GetProcesses() 108 { 109 List<ProcessInfo> procList = new List<ProcessInfo>(); 110 111 IntPtr handle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS | TH32CS_SNAPNOHEAPS, 0); 112 113 if ((Int32)handle == INVALID_HANDLE_VALUE) 114 throw new Win32Exception(Marshal.GetLastWin32Error(), "CreateToolhelp32Snapshot error."); 115 116 try 117 { 118 PROCESSENTRY processentry = new PROCESSENTRY(); 119 processentry.dwSize = (uint)Marshal.SizeOf(processentry); 120 121 //Get the first process 122 int retval = Process32First(handle, ref processentry); 123 124 while (retval == 1) 125 { 126 procList.Add(new ProcessInfo(new IntPtr((int)processentry.th32ProcessID), (int)processentry.cntThreads, (int)processentry.th32MemoryBase, (int)processentry.th32ParentProcessID)); 127 retval = Process32Next(handle, ref processentry); 128 } 129 } 130 finally 131 { 132 CloseToolhelp32Snapshot(handle); 133 } 134 135 return procList.ToArray(); 136 } 137 138 /// <summary> 139 /// Checks if the specified .EXE is running. 140 /// </summary> 141 /// <param name="fullpath">The full path to an .EXE file.</param> 142 /// <returns>Returns true is the process is running.</returns> 143 /// <exception cref="Win32Exception">Thrown when taking a system snapshot fails.</exception> 144 public static bool IsRunning(string fullpath) 145 { 146 return (FindProcessPID(fullpath) != IntPtr.Zero); 147 } 148 149 /// <summary> 150 /// Finds and kills if the process for the specified .EXE file is running. 151 /// </summary> 152 /// <param name="fullpath">The full path to an .EXE file.</param> 153 /// <returns>True if the process was terminated. False if the process was not found.</returns> 154 /// <exception cref="Win32Exception">Thrown when opening or killing the process fails.</exception> 155 public static bool FindAndKill(string fullpath) 156 { 157 IntPtr pid = FindProcessPID(fullpath); 158 159 if (pid == IntPtr.Zero) 160 return false; 161 162 Kill(pid); 163 164 return true; 165 } 166 167 /// <summary> 168 /// Terminates the process with the specified Process Id. 169 /// </summary> 170 /// <param name="pid">The Process Id of the process to kill.</param> 171 /// <exception cref="Win32Exception">Thrown when opening or killing the process fails.</exception> 172 internal static void Kill(IntPtr pid) 173 { 174 175 IntPtr process_handle = OpenProcess(PROCESS_TERMINATE, false, (int)pid); 176 177 if (process_handle == (IntPtr)INVALID_HANDLE_VALUE) 178 throw new Win32Exception(Marshal.GetLastWin32Error(), "OpenProcess failed."); 179 180 try 181 { 182 bool result = TerminateProcess(process_handle, 0); 183 184 if (result == false) 185 throw new Win32Exception(Marshal.GetLastWin32Error(), "TerminateProcess failed."); 186 187 } 188 finally 189 { 190 CloseHandle(process_handle); 191 } 192 } 193 194 /// <summary> 195 /// Finds the Process Id of the specified .EXE file. 196 /// </summary> 197 /// <param name="fullpath">The full path to an .EXE file.</param> 198 /// <returns>The Process Id to the process found. Return IntPtr.Zero if the process is not running.</returns> 199 ///<exception cref="Win32Exception">Thrown when taking a system snapshot fails.</exception> 200 public static IntPtr FindProcessPID(string fullpath) 201 { 202 fullpath = fullpath.ToLower(); 203 204 IntPtr snapshot_handle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS | TH32CS_SNAPNOHEAPS, 0); 205 206 if ((Int32)snapshot_handle == INVALID_HANDLE_VALUE) 207 throw new Win32Exception(Marshal.GetLastWin32Error(), "CreateToolhelp32Snapshot failed."); 208 209 try 210 { 211 PROCESSENTRY processentry = new PROCESSENTRY(); 212 processentry.dwSize = (uint)Marshal.SizeOf(processentry); 213 StringBuilder fullexepath = new StringBuilder(1024); 214 215 int retval = Process32First(snapshot_handle, ref processentry); 216 217 while (retval == 1) 218 { 219 IntPtr pid = new IntPtr((int)processentry.th32ProcessID); 220 221 // Writes the full path to the process into a StringBuilder object. 222 // Note: If first parameter is IntPtr.Zero it returns the path to the current process. 223 GetModuleFileName(pid, fullexepath, fullexepath.Capacity); 224 225 if (fullexepath.ToString().ToLower() == fullpath) 226 return pid; 227 228 retval = Process32Next(snapshot_handle, ref processentry); 229 } 230 } 231 finally 232 { 233 CloseToolhelp32Snapshot(snapshot_handle); 234 } 235 236 return IntPtr.Zero; 237 } 238 239 [DllImport("coredll.Dll", EntryPoint = "CreateProcess", SetLastError = true)] 240 public extern static int CreateProcess(string strImageName, string strCmdLine, IntPtr pProcessAttributes, 241 IntPtr pThreadAttributes, int bInheritsHandle, int dwCreationFlags, 242 IntPtr pEnvironment, IntPtr pCurrentDir, IntPtr bArray, ProcessContext oProc); 243 244 [DllImport("toolhelp.dll", SetLastError = true)] 245 private static extern IntPtr CreateToolhelp32Snapshot(uint flags, uint processID); 246 247 [DllImport("toolhelp.dll")] 248 private static extern int CloseToolhelp32Snapshot(IntPtr snapshot); 249 250 [DllImport("toolhelp.dll")] 251 private static extern int Process32First(IntPtr snapshot, ref PROCESSENTRY processEntry); 252 253 [DllImport("toolhelp.dll")] 254 private static extern int Process32Next(IntPtr snapshot, ref PROCESSENTRY processEntry); 255 256 [DllImport("coredll.dll", SetLastError = true)] 257 private static extern int GetModuleFileName(IntPtr hModule, StringBuilder lpFilename, int nSize); 258 259 [DllImport("coredll.dll", SetLastError = true)] 260 private static extern bool TerminateProcess(IntPtr hProcess, uint ExitCode); 261 262 [DllImport("coredll.dll", SetLastError = true)] 263 private static extern IntPtr OpenProcess(int flags, bool fInherit, int PID); 264 265 [DllImport("coredll.dll")] 266 private static extern bool CloseHandle(IntPtr handle); 267 268 private struct PROCESSENTRY 269 { 270 public uint dwSize; 271 public uint cntUsage; 272 public uint th32ProcessID; 273 public uint th32DefaultHeapID; 274 public uint th32ModuleID; 275 public uint cntThreads; 276 public uint th32ParentProcessID; 277 public int pcPriClassBase; 278 public uint dwFlags; 279 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH)] 280 public string szExeFile; 281 public uint th32MemoryBase; 282 public uint th32AccessKey; 283 } 284 285 } // end of class 286 287 public class ProcessContext 288 { 289 public Int32 hProcess; 290 public Int32 hThread; 291 public Int32 ProcessID; 292 public Int32 ThreadID; 293 } 294 }
转载于:https://www.cnblogs.com/roosf/p/5610338.html