在Windows Mobile和Wince(Windows Embedded CE)下如何使用.NET Compact Framework开发进程管理程序

1、在Windows Mobile和Wince(Windows Embedded CE)下如何使用.NET Compact Framework开发进程管理程序在.NET Compact Framework 的进程管理需要调用win32的API，也就是P/Invoke，在msnd上提供了这一P/Invoke的源代码, Creating a Microsoft .NET Compact Framework-based Process Manager Application,由于在技术交流群里有不同的人问同样的问题，因此打算写一下。Win32 API关键的API 如下：private 

2、;const int TH32CS_SNAPPROCESS = 0x00000002;        DllImport("toolhelp.dll")        public static extern IntPtr CreateToolhelp32Snapshot(uint flags, uint p

3、rocessid);        DllImport("toolhelp.dll")        public static extern int CloseToolhelp32Snapshot(IntPtr handle);        DllImport("toolhe

4、lp.dll")        public static extern int Process32First(IntPtr handle, byte pe);        DllImport("toolhelp.dll")        public

5、60;static extern int Process32Next(IntPtr handle, byte pe);        DllImport("coredll.dll")        private static extern IntPtr OpenProcess(int flags, 

6、;bool fInherit, int PID);        private const int PROCESS_TERMINATE = 1;        DllImport("coredll.dll")        private stat

7、ic extern bool TerminateProcess(IntPtr hProcess, uint ExitCode);        DllImport("coredll.dll")        private static extern bool CloseHandle(IntPtr handl

8、e);        private const int INVALID_HANDLE_VALUE = -1;调用上面的API就能就能轮询出所有的进程，可以杀死指定进程了。 Structures调用这些API需要下面的结构体 PROCESSENTRY32,结构体的转换是P/Invoke里面最难的部分，我曾经写过一篇这样的文章（.NET Compact Framework 下Win32 API P/Invoke 的使用），还是有很多需要学习和改进的地方，欢迎

9、指教。 #region PROCESSENTRY32 implementation/        typedef struct tagPROCESSENTRY32 /         /            DWORD dwSize;&

10、#160;/            DWORD cntUsage; /            DWORD th32ProcessID; /            DWORD th32Defa

11、ultHeapID; /            DWORD th32ModuleID; /            DWORD cntThreads; /            DWORD&#

12、160;th32ParentProcessID; /            LONG pcPriClassBase; /            DWORD dwFlags; /           &

13、#160;TCHAR szExeFileMAX_PATH; /            DWORD th32MemoryBase;/            DWORD th32AccessKey;/         PROCESSE

14、NTRY32;        private class PROCESSENTRY32                    / constants for structure definition     &

15、#160;      private const int SizeOffset = 0;            private const int UsageOffset = 4;           

16、0;private const int ProcessIDOffset=8;            private const int DefaultHeapIDOffset = 12;            private const int Mo

17、duleIDOffset = 16;            private const int ThreadsOffset = 20;            private const int ParentProcessIDOffset = 

18、;24;            private const int PriClassBaseOffset = 28;            private const int dwFlagsOffset = 32;    

19、;        private const int ExeFileOffset = 36;            private const int MemoryBaseOffset = 556;        

20、60;   private const int AccessKeyOffset = 560;            private const int Size = 564;            private con

21、st int MAX_PATH = 260;            / data members            public uint dwSize;          &

22、#160;  public uint cntUsage;             public uint th32ProcessID;             public uint th32DefaultHeapID;   &#

23、160;         public uint th32ModuleID;             public uint cntThreads;             public uint&#

24、160;th32ParentProcessID;             public long pcPriClassBase;             public uint dwFlags;         

25、;    public string szExeFile;            public uint th32MemoryBase;            public uint th32AccessKey;    

26、                /Default constructor            public PROCESSENTRY32()             &

27、#160;                      / create a PROCESSENTRY instance based on a byte array          

28、0;         public PROCESSENTRY32(byte aData)                            dwSize = GetUInt(aData,

29、 SizeOffset);                cntUsage = GetUInt(aData, UsageOffset);                th32ProcessID = GetUInt(aD

30、ata, ProcessIDOffset);                th32DefaultHeapID = GetUInt(aData, DefaultHeapIDOffset);                th32Module

31、ID = GetUInt(aData, ModuleIDOffset);                cntThreads = GetUInt(aData, ThreadsOffset);                

32、;th32ParentProcessID = GetUInt(aData, ParentProcessIDOffset);                pcPriClassBase = (long) GetUInt(aData, PriClassBaseOffset);        &

33、#160;       dwFlags = GetUInt(aData, dwFlagsOffset);                szExeFile = GetString(aData, ExeFileOffset, MAX_PATH);    

34、0;           th32MemoryBase = GetUInt(aData, MemoryBaseOffset);                th32AccessKey = GetUInt(aData, AccessKeyOffset); &#

35、160;                      #region Helper conversion functions            / utility:  get a 

36、;uint from the byte array            private static uint GetUInt(byte aData, int Offset)                 

37、           return BitConverter.ToUInt32(aData, Offset);                              

38、  / utility:  set a uint int the byte array            private static void SetUInt(byte aData, int Offset, int Value)    

39、0;                       byte buint = BitConverter.GetBytes(Value);                Buffer.

40、BlockCopy(buint, 0, aData, Offset, buint.Length);                        / utility:  get a ushort from the byte arr

41、ay            private static ushort GetUShort(byte aData, int Offset)                       

42、60;    return BitConverter.ToUInt16(aData, Offset);                                / utility:  

43、set a ushort int the byte array            private static void SetUShort(byte aData, int Offset, int Value)          

44、60;                 byte bushort = BitConverter.GetBytes(short)Value);                Buffer.BlockCopy(bushort, 0,&

45、#160;aData, Offset, bushort.Length);                                / utility:  get a unicode string

46、 from the byte array            private static string GetString(byte aData, int Offset, int Length)             

47、60;              String sReturn =  Encoding.Unicode.GetString(aData, Offset, Length);                return sReturn

48、;                                / utility:  set a unicode string in the byte array &

49、#160;          private static void SetString(byte aData, int Offset, string Value)                     &#

50、160;      byte arr = Encoding.ASCII.GetBytes(Value);                Buffer.BlockCopy(arr, 0, aData, Offset, arr.Length);      

51、;                  #endregion            / create an initialized data array        &#

52、160;   public byte ToByteArray()                            byte aData;          

53、;      aData = new byteSize;                /set the Size member                

54、SetUInt(aData, SizeOffset, Size);                return aData;                        

55、;public string Name                            get                

56、0;                   return szExeFile.Substring(0, szExeFile.IndexOf('0');                   

57、;                     public ulong PID                        

58、60;   get                                    return th32ProcessID;     

59、0;                                  public ulong BaseAddress          

60、                  get                               

61、60;    return th32MemoryBase;                                        public

62、 ulong ThreadCount                            get                 

63、;                   return cntThreads;                           

64、                 #endregionWrapped Class #region Process class    / <summary>    / Summary description for Process.  &#

65、160; / </summary>    public class Process            private string processName;        private IntPtr handle;    

66、    private int threadCount;        private int baseAddress;                /default constructor      

67、60; public Process()                                    private Process(IntPtr id, string 

68、procname, int threadcount, int baseaddress)                        handle = id;            

69、;processName = procname;            threadCount = threadcount;            baseAddress = baseaddress;        &#

70、160;       /ToString implementation for ListBox binding        public override string ToString()               

71、0;    return processName;                public int BaseAddress                    ge

72、t                            return baseAddress;                  

73、;          public int ThreadCount                    get              

74、              return threadCount;                            public IntPtr 

75、Handle                    get                            ret

76、urn handle;                            public string ProcessName             

77、60;      get                            return processName;           

78、                 public int BaseAddess                    get       &#

79、160;                    return baseAddress;                         &#

80、160;  public void Kill()                    IntPtr hProcess;                   &

81、#160;hProcess = OpenProcess(PROCESS_TERMINATE, false, (int) handle);            if(hProcess != (IntPtr) INVALID_HANDLE_VALUE)            

82、60;                bool bRet;                bRet = TerminateProcess(hProcess, 0);      &#

83、160;         CloseHandle(hProcess);                                    

84、0;   public static Process GetProcesses()                    ArrayList procList = new ArrayList();        

85、0;   IntPtr handle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);            if (int)handle > 0)              

86、60;             try                                    

87、PROCESSENTRY32 peCurrent;                    PROCESSENTRY32 pe32 = new PROCESSENTRY32();              

88、60;     /Get byte array to pass to the API calls                    byte peBytes = pe32.ToByteArray();   

89、                 /Get the first process                    int retval = Process32Firs

90、t(handle, peBytes);                    while(retval = 1)                     

91、60;                      /Convert bytes to the class                   

92、0;    peCurrent = new PROCESSENTRY32(peBytes);                        /New instance         

93、60;              Process proc = new Process(new IntPtr(int)peCurrent.PID), peCurrent.Name, (int)peCurrent.ThreadCount, (int)peCurrent.BaseAddress);       &

94、#160;                            procList.Add(proc);                  

95、      retval = Process32Next(handle, peBytes);                                   

96、;                 catch(Exception ex)                             

97、;       throw new Exception("Exception: " + ex.Message);                                &