C＃進程死亡

Question

我需要在c＃中編寫一個程序，該程序剛剛開始，殺死一個應該殺死並終止自己的進程\ exe。

我需要殺死的進程是另一個C＃應用程序，因此它是本地用戶進程，我知道exe的路徑。

Answer 1

首先搜索所有進程要殺死，比殺了它的進程。

Process[] runningProcesses = Process.GetProcesses(); 
foreach (Process process in runningProcesses) 
{ 
    // now check the modules of the process 
    foreach (ProcessModule module in process.Modules) 
    { 
     if (module.FileName.Equals("MyProcess.exe")) 
     { 
      process.Kill(); 
     } 
    } 
} 

Answer 2

您可以通過使用Process Class類來實現它，但您爲什麼要殺死另一個進程？

Answer 3

Process類具有殺（）方法

Answer 4

可以調用Process.Kill方法

可以使用Process.GetProcesses來獲取所有流程或Process.GetProcessByName或Process.GetProcessById這樣你就可以得到進程調用殺死。

Answer 5

退房Process.GetProcessesByName和Process.Kill

// Get all instances of Notepad running on the local 
// computer. 
Process [] localByName = Process.GetProcessesByName("notepad"); 
foreach(Process p in localByName) 
{ 
    p.Kill(); 
} 

Answer 6

由他們的名字殺死進程可以很容易地在C＃中完成（因爲其他答案已經完美顯示）。如果你想要基於可執行文件的完整路徑殺死進程，事情會變得更加棘手。一種方法是使用WMI，另一種方法是使用Windows API函數Module32First。

下面的示例使用後一種方法。它首先按名稱選擇正在運行的進程的子集，然後查詢每個進程的完整可執行文件路徑。請注意，此路徑將是正在執行的映像的實際路徑，這不一定是已啓動的可執行文件（例如，在x64系統上，calc.exe的實際路徑將爲C：\ Windows \ SysWOW64 \ calc.exe，即使文件C：\ Windows \ system32 \ calc.exe已啓動）。匹配路徑的所有過程都是由GetProcessesByPath返回：

using System; 
using System.Collections.Generic; 
using System.Diagnostics; 
using System.IO; 
using System.Runtime.ConstrainedExecution; 
using System.Runtime.InteropServices; 
using Microsoft.Win32.SafeHandles; 

class Program 
{ 
    static void Main(string[] args) 
    { 
     Process[] processList = GetProcessesByPath(@"C:\Program Files\MyCalculator\calc.exe"); 
     foreach (var process in processList) 
     { 
      if (!process.HasExited) 
       process.Kill(); 
     } 
    } 

    static Process[] GetProcessesByPath(string path) 
    { 
     List<Process> result = new List<Process>(); 

     string processName = Path.GetFileNameWithoutExtension(path); 
     foreach (var process in Process.GetProcessesByName(processName)) 
     { 
      ToolHelpHandle hModuleSnap = NativeMethods.CreateToolhelp32Snapshot(NativeMethods.SnapshotFlags.Module, (uint)process.Id); 
      if (!hModuleSnap.IsInvalid) 
      { 
       NativeMethods.MODULEENTRY32 me32 = new NativeMethods.MODULEENTRY32(); 
       me32.dwSize = (uint)System.Runtime.InteropServices.Marshal.SizeOf(me32); 
       if (NativeMethods.Module32First(hModuleSnap, ref me32)) 
       { 
        if (me32.szExePath == path) 
        { 
         result.Add(process); 
        } 
       } 
       hModuleSnap.Close(); 
      } 
     } 

     return result.ToArray(); 
    } 
} 

// 
// The safe handle class is used to safely encapsulate win32 handles below 
// 
public class ToolHelpHandle : SafeHandleZeroOrMinusOneIsInvalid 
{ 
    private ToolHelpHandle() 
     : base(true) 
    { 
    } 

    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)] 
    protected override bool ReleaseHandle() 
    { 
     return NativeMethods.CloseHandle(handle); 
    } 
} 
// 
// The following p/invoke wrappers are used to get the list of process and modules 
// running inside each process. 
// 
public class NativeMethods 
{ 
    [DllImport("kernel32.dll", SetLastError = true)] 
    static public extern bool CloseHandle(IntPtr hHandle); 

    [DllImport("kernel32.dll")] 
    static public extern bool Module32First(ToolHelpHandle hSnapshot, ref MODULEENTRY32 lpme); 

    [DllImport("kernel32.dll")] 
    static public extern bool Module32Next(ToolHelpHandle hSnapshot, ref MODULEENTRY32 lpme); 

    [DllImport("kernel32.dll")] 
    static public extern bool Process32First(ToolHelpHandle hSnapshot, ref PROCESSENTRY32 lppe); 

    [DllImport("kernel32.dll")] 
    static public extern bool Process32Next(ToolHelpHandle hSnapshot, ref PROCESSENTRY32 lppe); 

    [DllImport("kernel32.dll", SetLastError = true)] 
    static public extern ToolHelpHandle CreateToolhelp32Snapshot(SnapshotFlags dwFlags, uint th32ProcessID); 

    public const short INVALID_HANDLE_VALUE = -1; 

    [Flags] 
    public enum SnapshotFlags : uint 
    { 
     HeapList = 0x00000001, 
     Process = 0x00000002, 
     Thread = 0x00000004, 
     Module = 0x00000008, 
     Module32 = 0x00000010, 
     Inherit = 0x80000000, 
     All = 0x0000001F 
    } 

    [StructLayoutAttribute(LayoutKind.Sequential)] 
    public struct PROCESSENTRY32 
    { 
     public uint dwSize; 
     public uint cntUsage; 
     public uint th32ProcessID; 
     public IntPtr th32DefaultHeapID; 
     public uint th32ModuleID; 
     public uint cntThreads; 
     public uint th32ParentProcessID; 
     public int pcPriClassBase; 
     public uint dwFlags; 
     [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)] 
     public string szExeFile; 
    }; 

    [StructLayoutAttribute(LayoutKind.Sequential)] 
    public struct MODULEENTRY32 
    { 
     public uint dwSize; 
     public uint th32ModuleID; 
     public uint th32ProcessID; 
     public uint GlblcntUsage; 
     public uint ProccntUsage; 
     IntPtr modBaseAddr; 
     public uint modBaseSize; 
     IntPtr hModule; 
     [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)] 
     public string szModule; 
     [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)] 
     public string szExePath; 
    }; 
} 

某些代碼是基於由Jason Zander的文章可以發現here。

Answer 7

Process[] processes = Process.GetProcesses(); 
foreach (Process pr in processes){ 
    if (pr.ProcessName=="vfp") 
    if (pr.MainWindowTitle.Contains("test")) 
     pr.CloseMainWindow(); 
}`enter code here` 

這裏vfp是進程名稱。並測試是安裝標題名稱。

Answer 8

我想定義我自己的應用程序列表來關閉，所以我根據我見過的一些示例進行了設置。它簡單而有效。

 string[] Process_name_list = {"chrome","notepad"}; 
     foreach (string Process_name in Process_name_list) 
     { 
      foreach (var process in Process.GetProcessesByName(Process_name)) 
      {      
       process.Kill(); 
      } 
     }