Windows mobile 杀死Skype进程

1：当wm下GetProcesses不好用了，要杀特定的进程就只能通过窗体的标题了：

代码

using  System;
using  System.Linq;
using  System.Collections.Generic;
using  System.ComponentModel;
using  System.Data;
using  System.Drawing;
using  System.Text;
using  System.Windows.Forms;
using  System.Runtime.InteropServices;

namespace  KillPro
{
     public   partial   class  Form1 : Form
    {
         public  Form1()
        {
            InitializeComponent();
        }

         public   bool  KillProcessByWindowsTitle( string  title)
        {
            IntPtr hWnd  =  SafeNativeMethods.FindWindow( null , title);
             if  (hWnd  !=  IntPtr.Zero)
            {
                 int  processId  =   0 ;
                SafeNativeMethods.GetWindowThreadProcessId(hWnd,  ref  processId);
                IntPtr hProcess  =  IntPtr.Zero;
                hProcess  =  SafeNativeMethods.OpenProcess(SafeNativeMethods.PROCESS_ALL_ACCESS,  0 , processId);
                 if  (hProcess  !=  IntPtr.Zero)
                {
                     if  (SafeNativeMethods.TerminateProcess(hProcess,  1 ))
                    {
                        SafeNativeMethods.CloseHandle(hProcess);
                         return   true ;
                    }
                     else
                    {
                        SafeNativeMethods.CloseHandle(hProcess);
                         return   false ;
                    }
                }
                 else
                {
                     return   false ;
                }
            }
             return   false ;
        }

         private   void  button1_Click( object  sender, EventArgs e)
        {
            KillProcessByWindowsTitle( " 填入窗体标题即可 " );
            MessageBox.Show( " okOK " );
        }

    }

     internal   sealed   class  SafeNativeMethods
    {
        [DllImport( " coredll.dll " )]
         public   static   extern  IntPtr FindWindow( string  lpClassName,  string  lpWindowName);

         public   const   int  PROCESS_ALL_ACCESS  =   0x000F0000   |   0x00100000   |   0xFFF ;
        [DllImport( " coredll.dll " )]
         public   extern   static   int  GetWindowThreadProcessId(IntPtr hWnd,  ref   int  lpdwProcessId);
        [DllImport( " coredll.dll " )]
         public   extern   static  IntPtr OpenProcess( int  fdwAccess,  int  fInherit,  int  IDProcess);
        [DllImport( " coredll.dll " )]
         public   extern   static   bool  TerminateProcess(IntPtr hProcess,  int  uExitCode);
        [DllImport( " coredll.dll " )]
         public   extern   static   bool  CloseHandle(IntPtr hObject);
    }

}

2：也许大部分设备上，GetProcesses是好用的

using  System;
using  System.Linq;
// using System.Collections.Generic;
using  System.Text;
using  System.Runtime.InteropServices;
using  System.Collections;

namespace  Mobile
{
     class  Process
    {
         #region  Process class
         private   string  processName;
         private  IntPtr handle;
         private   int  threadCount;
         private   int  baseAddress;


         // default constructor
         public  Process()
        {

        }

         private  Process(IntPtr id,  string  procname,  int  threadcount,  int  baseaddress)
        {
            handle  =  id;
            processName  =  procname;
            threadCount  =  threadcount;
            baseAddress  =  baseaddress;
        }

         // ToString implementation for ListBox binding
         public   override   string  ToString()
        {
             return  processName;
        }

         public   int  BaseAddress
        {
             get
            {
                 return  baseAddress;
            }
        }

         public   int  ThreadCount
        {
             get
            {
                 return  threadCount;
            }
        }

         public  IntPtr Handle
        {
             get
            {
                 return  handle;
            }
        }

         public   string  ProcessName
        {
             get
            {
                 return  processName;
            }
        }

         public   int  BaseAddess
        {
             get
            {
                 return  baseAddress;
            }
        }


         public   void  Kill( IntPtr handle)
        {
            IntPtr hProcess;

            hProcess  =  OpenProcess(PROCESS_TERMINATE,  false , ( int )handle);

             if  (hProcess  !=  (IntPtr)INVALID_HANDLE_VALUE)
            {
                 bool  bRet;
                bRet  =  TerminateProcess(hProcess,  0 );
                CloseHandle(hProcess);
            }
        }

         public   static  Process[] GetProcesses()
        {
            ArrayList procList  =   new  ArrayList();

            IntPtr handle  =  CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,  0 );

             if  (( int )handle  >   0 )
            {
                 try
                {
                    PROCESSENTRY32 peCurrent;
                    PROCESSENTRY32 pe32  =   new  PROCESSENTRY32();
                     // Get byte array to pass to the API calls
                     byte [] peBytes  =  pe32.ToByteArray();
                     // Get the first process
                     int  retval  =  Process32First(handle, peBytes);

                     while  (retval  ==   1 )
                    {
                         // Convert bytes to the class
                        peCurrent  =   new  PROCESSENTRY32(peBytes);
                         // New instance
                        Process proc  =   new  Process( new  IntPtr(( int )peCurrent.PID), peCurrent.Name, ( int )peCurrent.ThreadCount, ( int )peCurrent.BaseAddress);

                        procList.Add(proc);

                        retval  =  Process32Next(handle, peBytes);
                    }
                }
                 catch  (Exception ex)
                {
                     throw   new  Exception( " Exception:  "   +  ex.Message);
                }

                 // Close handle
                CloseToolhelp32Snapshot(handle);

                 return  (Process[])procList.ToArray( typeof (Process));

            }
             else
            {
                 // throw new Exception("Unable to create snapshot");
                 return   null ;
            }
        }

         #endregion


         #region  PROCESSENTRY32 implementation

         private   class  PROCESSENTRY32
        {
             //  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 ;

             //  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;

             // Default constructor
             public  PROCESSENTRY32()
            {


            }

             //  create a PROCESSENTRY instance based on a byte array        
             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   ulong  PID
            {
                 get
                {
                     return  th32ProcessID;
                }
            }

             public   ulong  BaseAddress
            {
                 get
                {
                     return  th32MemoryBase;
                }
            }

             public   ulong  ThreadCount
            {
                 get
                {
                     return  cntThreads;
                }
            }
        }
         #endregion

         #region  PInvoke declarations
         private   const   int  TH32CS_SNAPPROCESS  =   0x00000002 ;
        [DllImport( " toolhelp.dll " )]
         public   static   extern  IntPtr CreateToolhelp32Snapshot( uint  flags,  uint  processid);
        [DllImport( " toolhelp.dll " )]
         public   static   extern   int  CloseToolhelp32Snapshot(IntPtr handle);
        [DllImport( " toolhelp.dll " )]
         public   static   extern   int  Process32First(IntPtr handle,  byte [] pe);
        [DllImport( " toolhelp.dll " )]
         public   static   extern   int  Process32Next(IntPtr handle,  byte [] pe);
        [DllImport( " coredll.dll " )]
         private   static   extern  IntPtr OpenProcess( int  flags,  bool  fInherit,  int  PID);
         private   const   int  PROCESS_TERMINATE  =   1 ;
        [DllImport( " coredll.dll " )]
         private   static   extern   bool  TerminateProcess(IntPtr hProcess,  uint  ExitCode);
        [DllImport( " coredll.dll " )]
         private   static   extern   bool  CloseHandle(IntPtr handle);
         private   const   int  INVALID_HANDLE_VALUE  =   - 1 ;

         #endregion



    }
}

 

using  System;
using  System.Linq;
using  System.Collections.Generic;
using  System.ComponentModel;
using  System.Data;
using  System.Drawing;
using  System.Text;
using  System.Windows.Forms;

namespace  Mobile
{
     public   partial   class  Form1 : Form
    {
         public  Form1()
        {
            InitializeComponent();
        }

         private   void  button1_Click( object  sender, EventArgs e)
        {
            Process[] a  =  Process.GetProcesses(); 
             for  ( int  i  =   0 ; i  <  a.Length; i ++ )
            {
                MessageBox.Show(a[i].ProcessName);
                 if  (a[i].ProcessName  == " Skype-PPC.exe " )
                {
                    Process pp  =   new  Process();
                    pp.Kill(a[i].Handle);
                    MessageBox.Show( " kill clean " );
                }
               
            }

            MessageBox.Show( " OK " );
        }

    }
}

/Files/tt_mc/Mobile.rar