C# Process Killing

Question

Ho bisogno di scrivere un programma in C# che dovrebbe solo iniziare, uccidere un processo \ exe che dovrebbe uccidere e terminare se stesso.

Il processo che devo eliminare è un'altra applicazione C# in modo che si tratti di un processo utente locale e conosco il percorso exe ​​.

Answer 1

Prima di ricerca tutti i processi per il processo che si vuole uccidere, di ucciderlo.

Answer 2

È possibile raggiungerlo utilizzando la classe Process Class ma perché si desidera annullare un altro processo?

Answer 3

classe Process ha metodo di uccisione()

Answer 4

è possibile chiamare il metodo Process.Kill

è possibile utilizzare il Process.GetProcesses per ottenere tutti i processi o Process.GetProcessByName o Process.GetProcessById in modo da poter ottenere il processo di chiamare Uccidi su.

Answer 5

Partenza Process.GetProcessesByName e 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

I processi di uccisione con il loro nome possono essere facilmente eseguiti in C# (come le altre risposte hanno già mostrato perfettamente). Se tuttavia si desidera eliminare i processi in base al percorso completo dell'eseguibile, le cose diventano più complicate. Un modo per farlo sarebbe quello di utilizzare WMI, un altro modo sarebbe quello di utilizzare la funzione API di Windows Module32First.

L'esempio seguente utilizza il secondo approccio. Seleziona prima un sottoinsieme dei processi in esecuzione con il loro nome e quindi interroga ciascuno di questi processi per il loro percorso completo eseguibile. Si noti che questo percorso sarà il percorso effettivo dell'immagine in esecuzione, che non è necessariamente l'eseguibile che è stato avviato (ad esempio sui sistemi x64 il percorso effettivo per calc.exe sarà C: \ Windows \ SysWOW64 \ calc.exe anche se è stato avviato il file C: \ Windows \ system32 \ calc.exe). Tutti i processi con un percorso di corrispondenza vengono restituiti da 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; 
    }; 
} 

Parte del codice si basa su un articolo di Jason Zander che può essere trovato 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` 

Qui vfp è il nome del processo. e test è il nome del titolo di installazione.

Answer 8

Volevo definire la mia lista di applicazioni da chiudere, così l'ho reso basato su alcuni degli esempi che ho visto elencato. È semplice ed efficace

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