name - stop all processes c#

C#Proceso de Matanza

Question

Necesito escribir un programa en c # que simplemente comience, elimine un proceso / exe que se supone que debe matar y finalice.

El proceso que necesito eliminar es otra aplicación de C #, por lo que es un proceso de usuario local y conozco la ruta al archivo ejecutable .

Answer 1

Echa un vistazo a Process.GetProcessesByName y 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 2

La clase de proceso tiene el método Kill ()

Answer 3

Los procesos de matanza por su nombre se pueden hacer fácilmente en C # (como las otras respuestas ya mostraron perfectamente). Sin embargo, si quieres eliminar procesos basados ​​en la ruta completa de las cosas ejecutables, hazlo más complicado. Una forma de hacerlo sería usar WMI, otra manera sería usar la función API de Module32First Windows.

La muestra de abajo utiliza el último enfoque. Primero selecciona un subconjunto de los procesos en ejecución por su nombre y luego consulta cada uno de estos procesos para su ruta ejecutable completa. Tenga en cuenta que esta ruta será la ruta real de la imagen que se está ejecutando, que no es necesariamente el ejecutable que se lanzó (por ejemplo, en los sistemas x64, la ruta real a calc.exe será C: / Windows / SysWOW64 / calc.exe incluso si se inició el archivo C: / Windows / system32 / calc.exe). GetProcessesByPath devuelve todos los procesos con una ruta coincidente:

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 código se basa en un artículo de Jason Zander que se puede encontrar here .

Answer 4

Primero busque en todos los procesos el proceso que desea matar, y luego elimínelo.

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 5

Puede lograrlo usando la clase de clase de proceso , pero ¿por qué querría matar otro proceso?

Answer 6

Quería definir mi propia lista de aplicaciones para cerrar, así que hice esto en base a algunos de los ejemplos que he visto en la lista. Es simple y eficaz.

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

Answer 7

puedes llamar al método Process.Kill

puede usar Process.GetProcesses para obtener todos los procesos o Process.GetProcessByName o Process.GetProcessById para que pueda obtener el proceso para activar Kill.

Answer 8

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

Aquí vfp es el nombre del proceso. y prueba es el nombre del título de configuración.