【原创】windows 进程管理

【原创】windows 进程管理

pc 平台进程管理方法：

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
    Dim TargetName As String = "ibmdict" '存储进程名为文本型，注:进程名不加扩展名
    Dim TargetKill() As Process = Process.GetProcessesByName(TargetName) '从进程名获取进程
    Dim TargetPath As String '存储进程路径为文本型

    If TargetKill.Length > 0 Then    '判断进程名的数量，如果同名进程数量在2个以上，用For循环关闭进程。
        For i = 0 To TargetKill.Length - 1
            TargetPath = TargetKill(i).MainModule.FileName
            TargetKill(i).Kill()
        Next
    ElseIf TargetKill.Length = 0 Then '判断进程名的数量，没有发现进程直接弹窗。不需要的，可直接删掉该If子句
        MsgBox("没有发现进程!")
        Exit Sub
    End If
    MsgBox("已终止" & TargetKill.Length & "个进程") '弹窗提示已终止多少个进程

 End Sub

WINCE平台方法：

WINCE平台由于不支持GetProcessesByName，所以，最好的办法是自己编写程序，demo界面如下：

完整程序如下：

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;
using System.Collections;
namespace SmartDeviceProject1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        static void Massin(string[] args)
        {
            if (args.Length == 0)
            {
                Console.WriteLine("Please enter the process name.");
                return;
            }
            string processName = args[0].ToUpper() ;
            if (processName.Contains(".EXE") == false) processName += ".EXE";
            Process[] processes = Process.GetProcesses();
            foreach (Process proc in processes)
            {
                if (proc.ProcessName.ToUpper() == processName)
                {
                    proc.Kill();
                    MessageBox .Show (processName+" was killed.");
                    break;
                }
            }
        }
        private void button1_Click(object sender, EventArgs e)
        {
            string[] exe = { "notepad++" };
            exe[0] = textBox1.Text.ToString();
            Massin(exe);
        }
        private void button2_Click(object sender, EventArgs e)
        {
            Process[] processes = Process.GetProcesses();
            listBox1.Items.Clear();
            foreach (Process proc in processes)
            {
                listBox1.Items.Add(proc.ProcessName);
            }
        }
        private void listBox1_SelectedIndexChanged(object sender, EventArgs e)
        {
           textBox1 .Text =  listBox1.SelectedItem.ToString();
        }
    }
        #region PROCESSENTRY32 implementation
        //        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;
        public  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 Process class
    /// <summary>
    /// Summary description for Process.
    /// </summary>
    public class Process
    {
        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;
        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 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");
            }
        }
    }
#endregion
}