[Windows Mobile 6.x] 如何获得当前运行的所有进程

.Net Compact Framework的进程管理并不像Full framework那么方便。经过我的尝试，如果要获得Windows Mobile 6.x当前运行的所有进程，可以这样实现：

1. 封装ToolHelp.dll中涉及到的几个API：

//--------------------------------------------------------------------------- // <copyright file="ToolHelp.cs" company="Yaping Xin"> // Copyright (c) Yaping Xin. All rights reserved. // </copyright> // <Description>Helper class for Native Methods in ToolHelp.dll</Description> // <Link>http://msdn.microsoft.com/en-us/library/ms858621.aspx</Link> // <Version>1.0</Version> // <Created>2010-09-10 22:20</Created> // <LastUpdated>2010-09-10 22:20</LastUpdated> //--------------------------------------------------------------------------- namespace MobileAutomation.PhoneCore.NativeMethods { using System; using System.Runtime.InteropServices; using MobileAutomation.PhoneCore.NativeStructures; /// <summary> /// Helper class for Native Methods in ToolHelp.dll /// Link: http://msdn.microsoft.com/en-us/library/ms858621.aspx /// </summary> public static class ToolHelp { /// <summary> /// This function takes a snapshot of the processes, heaps, modules, and threads used by the processes. /// Link: http://msdn.microsoft.com/en-us/library/aa911386.aspx /// Syntax: HANDLE WINAPI CreateToolhelp32Snapshot(DWORD dwFlags, DWORD th32ProcessID); /// </summary> /// <param name="flags">[in] Portions of the system to include in the snapshot. The following table shows possible values.</param> /// <param name="processId">[in] Process identifier. </param> /// <returns>An open handle to the specified snapshot indicates success. INVALID_HANDLE_VALUE indicates failure.</returns> [DllImport("toolhelp.dll")] public static extern IntPtr CreateToolhelp32Snapshot(uint flags, uint processId); /// <summary> /// This function closes a handle to a snapshot. /// Link: http://msdn.microsoft.com/en-us/library/aa914612.aspx /// Syntax: BOOL WINAPI CloseToolhelp32Snapshot(HANDLE hSnapshot); /// </summary> /// <param name="handle">[in] Handle to a snapshot returned from the CreateToolhelp32Snapshot function.</param> /// <returns>TRUE indicates success. FALSE indicates failure.</returns> [DllImport("toolhelp.dll")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool CloseToolhelp32Snapshot(IntPtr handle); /// <summary> /// This function retrieves information about the first process encountered in a system snapshot. /// Link: http://msdn.microsoft.com/en-us/library/aa915359.aspx /// Syntax: BOOL WINAPI Process32First(HANDLE hSnapshot, LPPROCESSENTRY32 lppe); /// </summary> /// <param name="handle">[in] Handle to the snapshot returned from a previous call to the CreateToolhelp32Snapshot function.</param> /// <param name="pe">[out] Pointer to a PROCESSENTRY32 structure.</param> /// <returns>TRUE indicates that the first entry of the process list has been copied to the buffer. FALSE indicates failure.</returns> [DllImport("toolhelp.dll")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool Process32First(IntPtr handle, byte[] pe); /// <summary> /// This function retrieves information about the next process recorded in a system snapshot. /// Link: http://msdn.microsoft.com/en-us/library/aa908729.aspx /// Syntax: BOOL WINAPI Process32Next(HANDLE hSnapshot, LPPROCESSENTRY32 lppe); /// </summary> /// <param name="handle">[in] Handle to the snapshot returned from a previous call to the CreateToolhelp32Snapshot function.</param> /// <param name="pe">[out] Pointer to a PROCESSENTRY32 structure.</param> /// <returns>TRUE indicates that the next entry of the process list has been copied to the buffer. FALSE indicates failure.</returns> [DllImport("toolhelp.dll")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool Process32Next(IntPtr handle, byte[] pe); } }

2. 封装coredll.dll中涉及到的几个API：

//--------------------------------------------------------------------------- // <copyright file="CoreDll.cs" company="Yaping Xin"> // Copyright (c) Yaping Xin. All rights reserved. // </copyright> // <Description>Helper class for Native Methods in coredll.dll</Description> // <Version>1.0</Version> // <Created>2010-08-03 14:32</Created> // <LastUpdated>2010-09-10 15:12</LastUpdated> //--------------------------------------------------------------------------- namespace MobileAutomation.PhoneCore.NativeMethods { using System; using System.Runtime.InteropServices; using System.Text; using MobileAutomation.PhoneCore.NativeStructures; /// <summary> /// Helper class for Native Methods in coredll.dll /// </summary> public static class CoreDll { #region Const Definition /// <summary>const int PROCESS_TERMINATE = 1;</summary> public const int ProcessTerminate = 1; /// <summary>const int INVALID_HANDLE_VALUE = -1;</summary> public const int InvalidHandleValue = -1; /// <summary>Max text length in GetClassName()</summary> public const int MaxWindowClassNameLength = 256; #endregion #region Process Management /// <summary> /// This function returns a handle to an existing process object. When you finish with the handle, close it using the CloseHandle function. /// Link: http://msdn.microsoft.com/en-us/library/aa909175.aspx /// Syntax: HANDLE OpenProcess(DWORD fdwAccess, BOOL fInherit, DWORD IDProcess); /// </summary> /// <param name="flags">[in] Not supported; set to zero.</param> /// <param name="inherit">[in] Not supported; set to FALSE.</param> /// <param name="pid">[in] Specifies the process identifier of the process to open.</param> /// <returns>An open handle to the specified process indicates success. NULL indicates failure. To get extended error information, call GetLastError. </returns> [DllImport("coredll.dll")] public static extern IntPtr OpenProcess(int flags, bool inherit, int pid); /// <summary> /// This function closes the specified process and all of its threads. /// Link: http://msdn.microsoft.com/en-us/library/aa908764.aspx /// Syntax: BOOL TerminateProcess(HANDLE hProcess, DWORD uExitCode); /// </summary> /// <param name="processhandler">[in] Handle to the process to terminate. This is a handle returned from OpenProcess.</param> /// <param name="exitCode">[in] Specifies the exit code for the process and for all threads terminated as a result of this call.</param> /// <returns>Nonzero indicates success. Zero indicates failure. To get extended error information, call GetLastError.</returns> [DllImport("coredll.dll")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool TerminateProcess(IntPtr processhandler, uint exitCode); #endregion /// <summary> /// Closes an open object handle. /// Link: http://msdn.microsoft.com/en-us/library/aa914720.aspx /// Syntax: BOOL CloseHandle(HANDLE hObject); /// </summary> /// <param name="objectHandler">[in] HANDLE hObject: Handle to an open object.</param> /// <returns>BOOL: Nonzero indicates success. Zero indicates failure. To get extended error information, call GetLastError.</returns> [DllImport("coredll.dll", SetLastError = true, CallingConvention = CallingConvention.Winapi, CharSet = CharSet.Auto)] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool CloseHandle(IntPtr objectHandler); } }

3. 封装PROCESSENTRY32这个结构体

namespace MobileAutomation.PhoneCore.NativeStructures { using System; using System.Runtime.InteropServices; using System.Text; /// <summary> /// This class defines the PROCESSENTRY32 structure. /// Link: http://msdn.microsoft.com/en-us/library/aa911518.aspx /// Original Definition: /// typedef struct tagPROCESSENTRY32 { /// DWORD dwSize; /// DWORD cntUsage; /// DWORD th32ProcessID; /// DWORD th32DefaultHeapID; /// DWORD th32ModuleID; /// DWORD cntThreads; /// DWORD th32ParentProcessID; /// LONG pcPriClassBase; /// DWORD dwFlags; /// TCHAR szExeFile[MAX_PATH]; /// DWORD th32MemoryBase; /// DWORD th32AccessKey; /// } PROCESSENTRY32; /// typedef PROCESSENTRY32* PPROCESSENTRY32; /// typedef PROCESSENTRY32* LPPROCESSENTRY32; /// </summary> [StructLayout(LayoutKind.Sequential)] public class ProcessEntry32 { #region constants for structure definition private const int SizeOffset = 0; private const int UsageOffset = 4; private const int ProcessIDOffset = 8; private const int DefaultHeapIDOffset = 12; private const int ModuleIDOffset = 16; private const int ThreadsOffset = 20; private const int ParentProcessIDOffset = 24; private const int PriClassBaseOffset = 28; private const int dwFlagsOffset = 32; private const int ExeFileOffset = 36; private const int MemoryBaseOffset = 556; private const int AccessKeyOffset = 560; private const int Size = 564; private const int MAX_PATH = 260; #endregion #region data members public uint dwSize; public uint cntUsage; public uint th32ProcessID; public uint th32DefaultHeapID; public uint th32ModuleID; public uint cntThreads; public uint th32ParentProcessID; public long pcPriClassBase; public uint dwFlags; public string szExeFile; public uint th32MemoryBase; public uint th32AccessKey; #endregion /// <summary> /// Default constructor /// </summary> public ProcessEntry32() { } /// <summary> /// create a PROCESSENTRY instance based on a byte array /// </summary> /// <param name="aData">byte[] data</param> public ProcessEntry32(byte[] aData) { dwSize = GetUInt(aData, SizeOffset); cntUsage = GetUInt(aData, UsageOffset); th32ProcessID = GetUInt(aData, ProcessIDOffset); th32DefaultHeapID = GetUInt(aData, DefaultHeapIDOffset); th32ModuleID = GetUInt(aData, ModuleIDOffset); cntThreads = GetUInt(aData, ThreadsOffset); th32ParentProcessID = GetUInt(aData, ParentProcessIDOffset); pcPriClassBase = (long)GetUInt(aData, PriClassBaseOffset); dwFlags = GetUInt(aData, dwFlagsOffset); szExeFile = GetString(aData, ExeFileOffset, MAX_PATH); th32MemoryBase = GetUInt(aData, MemoryBaseOffset); th32AccessKey = GetUInt(aData, AccessKeyOffset); } #region Helper conversion functions // utility: get a uint from the byte array private static uint GetUInt(byte[] aData, int Offset) { return BitConverter.ToUInt32(aData, Offset); } // utility: set a uint int the byte array private static void SetUInt(byte[] aData, int Offset, int Value) { byte[] buint = BitConverter.GetBytes(Value); Buffer.BlockCopy(buint, 0, aData, Offset, buint.Length); } // utility: get a ushort from the byte array private static ushort GetUShort(byte[] aData, int Offset) { return BitConverter.ToUInt16(aData, Offset); } // utility: set a ushort int the byte array private static void SetUShort(byte[] aData, int Offset, int Value) { byte[] bushort = BitConverter.GetBytes((short)Value); Buffer.BlockCopy(bushort, 0, aData, Offset, bushort.Length); } // utility: get a unicode string from the byte array private static string GetString(byte[] aData, int Offset, int Length) { String sReturn = Encoding.Unicode.GetString(aData, Offset, Length); return sReturn; } // utility: set a unicode string in the byte array private static void SetString(byte[] aData, int Offset, string Value) { byte[] arr = Encoding.ASCII.GetBytes(Value); Buffer.BlockCopy(arr, 0, aData, Offset, arr.Length); } #endregion // create an initialized data array public byte[] ToByteArray() { byte[] aData; aData = new byte[Size]; //set the Size member SetUInt(aData, SizeOffset, Size); return aData; } public string Name { get { return szExeFile.Substring(0, szExeFile.IndexOf('\0')); } } public uint PID { get { return th32ProcessID; } } public uint BaseAddress { get { return th32MemoryBase; } } public uint ThreadCount { get { return cntThreads; } } } }

4. 我们的进程管理类：ProcessInfo

//--------------------------------------------------------------------------- // <copyright file="ProcessInfo.cs" company="Yaping Xin"> // Copyright (c) Yaping Xin. All rights reserved. // </copyright> // <Description>Description for Process.</Description> // <Author>Yaping Xin</Author> // <Version>1.0</Version> // <Created>2010-09-10 22:20</Created> // <LastUpdated>2010-09-10 22:20</LastUpdated> //--------------------------------------------------------------------------- namespace MobileAutomation.PhoneCore.Common { using System; using System.Collections; using MobileAutomation.PhoneCore.NativeMethods; using MobileAutomation.PhoneCore.NativeStructures; /// <summary> /// Description for Process. /// </summary> public class ProcessInfo { #region Private Data Members /// <summary>Process Name</summary> private string processName; /// <summary>Process handle</summary> private IntPtr handle; /// <summary>Process thread count</summary> private int threadCount; /// <summary>Process base address</summary> private IntPtr baseAddress; #endregion #region Initialization /// <summary> /// Initializes a new instance of the ProcessInfo class. /// </summary> public ProcessInfo() { } /// <summary> /// Initializes a new instance of the ProcessInfo class with ProcessEntry32 object. /// </summary> /// <param name="processEntry32">the ProcessEntry32 object</param> public ProcessInfo(ProcessEntry32 processEntry32) { this.handle = new IntPtr((int)processEntry32.th32ProcessID); this.processName = processEntry32.Name; this.threadCount = (int)processEntry32.ThreadCount; this.baseAddress = new IntPtr((int)processEntry32.th32MemoryBase); } #endregion #region Public Properties /// <summary> /// Gets Process Name property /// </summary> public string ProcessName { get { return this.processName; } } /// <summary> /// Gets Base Address property /// </summary> public IntPtr BaseAddress { get { return this.baseAddress; } } /// <summary> /// Gets Thread Count property /// </summary> public int ThreadCount { get { return this.threadCount; } } /// <summary> /// Gets Process ID property /// </summary> public IntPtr ProcessId { get { return this.handle; } } #endregion #region Public Methods /// <summary> /// Gets process list /// </summary> /// <returns>process list</returns> public static ProcessInfo[] GetProcesses() { ArrayList processList = new ArrayList(); IntPtr handle = ToolHelp.CreateToolhelp32Snapshot((uint)(TH32CS.SnapProcess | TH32CS.SnapNoHeaps), 0); if ((int)handle > 0) { try { ProcessEntry32 current; ProcessEntry32 processEntry32 = new ProcessEntry32(); // Get byte array to pass to the API calls byte[] bytes = processEntry32.ToByteArray(); // Get the first process bool retval = ToolHelp.Process32First(handle, bytes); while (retval) { // Convert bytes to the class current = new ProcessEntry32(bytes); // New instance ProcessInfo proc = new ProcessInfo(current); processList.Add(proc); retval = ToolHelp.Process32Next(handle, bytes); } } catch (Exception e) { throw new Exception("Exception: " + e.Message); } ToolHelp.CloseToolhelp32Snapshot(handle); return (ProcessInfo[])processList.ToArray(typeof(ProcessInfo)); } else { throw new Exception("Unable to create snapshot"); } } /// <summary> /// ToString() implementation. /// </summary> /// <returns>ToString() value</returns> public override string ToString() { return this.ProcessName; } /// <summary> /// Kill the process /// </summary> public void Kill() { IntPtr process; process = CoreDll.OpenProcess(CoreDll.ProcessTerminate, false, (int)this.ProcessId); if (process != (IntPtr)CoreDll.InvalidHandleValue) { // bRet = CoreDll.AllocHGlobalTerminateProcess(processHandle, 0); CoreDll.TerminateProcess(process, 0); // CoreDll.AllocHGlobalCloseHandle(processHandle); CoreDll.CloseHandle(process); } } #endregion } }

5. 调用：

ProcessInfo[] processes = ProcessInfo.GetProcesses();

这样我们就得到了当前所有的进程。

6. 参考文献

• 《Creating a Microsoft .NET Compact Framework-based Process Manager Application》http://msdn.microsoft.com/en-us/library/aa446560.aspx
• Discuss: GetProcesses() on WM6 http://social.msdn.microsoft.com/Forums/en-US/windowsmobiledev/thread/86e4b60a-bba5-4727-8424-5962ca4cf7d6
• PROCESSENTRY32 Structure http://msdn.microsoft.com/en-us/library/ms684839%28VS.85%29.aspx
• ToolHelp Functions http://msdn.microsoft.com/en-us/library/aa915058.aspx