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);
}
}
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.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");
}
}
}
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");
}
}
}