Freigeben über


Terminate-Methode der Win32_Process-Klasse

Die TerminateWMI-Klassenmethode beendet einen Prozess und alle zugehörigen Threads.

In diesem Thema wird MOF-Syntax (Managed Object Format) verwendet. Weitere Informationen zur Verwendung dieser Methode finden Sie unter Aufrufen einer Methode.

Syntax

uint32 Terminate(
  [in] uint32 Reason
);

Parameter

Grund [in]

Exitcode für den Prozess und für alle Threads, die als Ergebnis dieses Aufrufs beendet wurden.

Rückgabewert

Gibt den Wert 0 (null) zurück, wenn der Prozess erfolgreich beendet wurde, und eine beliebige andere Zahl, die auf einen Fehler hinweist. Weitere Fehlercodes finden Sie unter WMI-Fehlerkonstanten oder WbemErrorEnum. Allgemeine HRESULT-Werte finden Sie unter Systemfehlercodes.

Erfolgreicher Abschluss (0)

Zugriff verweigert (2)

Unzureichende Berechtigungen (3)

Unbekannter Fehler (8)

Pfad nicht gefunden (9)

Ungültiger Parameter (21)

Sonstige (22 4294967295)

Bemerkungen

Übersicht

Computerprobleme sind häufig auf einen Prozess zurückzuführen, der nicht mehr wie erwartet funktioniert. Beispielsweise kann der Prozess arbeitsspeicherverlustend sein oder nicht mehr auf Benutzereingaben reagieren. Wenn probleme wie diese auftreten, muss der Prozess beendet werden. Obwohl dies wie eine einfache Aufgabe erscheinen mag, kann das Beenden eines Prozesses durch mehrere Faktoren erschwert werden:

  • Der Prozess kann hängen geblieben sein und reagiert daher nicht mehr auf Menü- oder Tastaturbefehle zum Schließen der Anwendung. Dies macht es für den typischen Benutzer kaum möglich, die Anwendung zu schließen und den Prozess zu beenden.
  • Der Prozess ist möglicherweise verwaist. Beispielsweise kann ein Skript eine instance von Word erstellen und dann beenden, ohne diese instance zu zerstören. Tatsächlich bleibt Word auf dem Computer ausgeführt, obwohl keine Benutzeroberfläche sichtbar ist. Da keine Benutzeroberfläche vorhanden ist, stehen keine Menü- oder Tastaturbefehle zum Beenden des Prozesses zur Verfügung.
  • Möglicherweise wissen Sie nicht, welcher Prozess beendet werden muss. Beispielsweise können Sie alle Programme beenden, die eine angegebene Arbeitsspeichermenge überschreiten.
  • Da Sie im Task-Manager nur die von Ihnen erstellten Prozesse beenden können, können Sie einen Prozess möglicherweise nicht beenden, selbst wenn Sie ein Administrator auf dem Computer sind.

Skripts ermöglichen es Ihnen, all diese potenziellen Hindernisse zu überwinden, sodass Sie eine beträchtliche administrative Kontrolle über Ihre Computer haben. Wenn Sie beispielsweise vermuten, dass Benutzer Spiele spielen, die in Ihrem organization verboten wurden, können Sie ganz einfach ein Skript schreiben, um eine Verbindung mit jedem Computer herzustellen, zu ermitteln, ob das Spiel ausgeführt wird, und den Prozess sofort beenden.

Verwenden der Terminate-Methode

Sie können einen Prozess wie folgt beenden:

  • Beenden eines Prozesses, der derzeit ausgeführt wird. Beispielsweise müssen Sie möglicherweise ein Diagnoseprogramm beenden, das auf einem Remotecomputer ausgeführt wird. Wenn es keine Möglichkeit gibt, die Anwendung remote zu steuern, können Sie den Prozess für diese Anwendung einfach beenden.
  • Verhindern, dass ein Prozess überhaupt ausgeführt wird. Durch die kontinuierliche Überwachung der Prozesserstellung auf einem Computer können Sie jeden Prozess identifizieren und sofort beenden, sobald er gestartet wird. Dies bietet eine Methode, um sicherzustellen, dass bestimmte Anwendungen (z. B. Programme, die große Mediendateien über das Internet herunterladen) niemals auf bestimmten Computern ausgeführt werden.

Hinweis

Gruppenrichtlinie können auch verwendet werden, um die Programme einzuschränken, die auf einem Computer ausgeführt werden. Gruppenrichtlinie kann jedoch nur die Programme einschränken, die entweder über das Startmenü oder windows Explorer ausgeführt werden. Dies hat keine Auswirkungen auf Programme, die mit anderen Mitteln wie der Befehlszeile gestartet werden. Im Gegensatz dazu kann WMI verhindern, dass ein Prozess ausgeführt wird, unabhängig davon, wie der Prozess gestartet wurde.

Beenden eines Prozesses, den Sie nicht besitzen

Um einen Prozess zu beenden, den Sie nicht besitzen, aktivieren Sie die Berechtigung SeDebugPrivilege . In VBScript können Sie diese Berechtigung mit den folgenden Codezeilen aktivieren:

Set objLoc = createobject("wbemscripting.swbemlocator")
objLoc.Security_.privileges.addasstring "sedebugprivilege", true

Weitere Informationen zum Aktivieren dieser Berechtigung in C++ finden Sie unter Aktivieren und Deaktivieren von Berechtigungen in C++.

Beispiele

Das PowerShell-Codebeispiel Zum Beenden des ausgeführten Prozesses auf mehreren Servern im TechNet-Katalog wird ein Prozess beendet, der auf einem einzelnen oder mehreren Computern ausgeführt wird.

Im folgenden VBScript-Beispiel wird der Prozess beendet, in dem die Anwendung Diagnose.exe derzeit ausgeführt wird.

strComputer = "."
Set objWMIService = GetObject("winmgmts:" & "{impersonationLevel=impersonate}!\\" & strComputer & "\root\cimv2")
Set colProcessList = objWMIService.ExecQuery("SELECT * FROM Win32_Process WHERE Name = 'Diagnose.exe'")
For Each objProcess in colProcessList
 objProcess.Terminate()
Next

Im folgenden VBScript-Beispiel wird ein temporärer Ereignisconsumer verwendet, um einen Prozess zu beenden, sobald er gestartet wird.

strComputer = "."
Set objWMIService = GetObject("winmgmts:" & "{impersonationLevel=impersonate}!\\" & strComputer & "\root\cimv2")
Set colMonitoredProcesses = objWMIService.ExecNotificationQuery("SELECT * FROM __InstanceCreationEvent " _
 & " WITHIN 1 WHERE TargetInstance ISA 'Win32_Process'")
i = 0
Do While i = 0
 Set objLatestProcess = colMonitoredProcesses.NextEvent
 If objLatestProcess.TargetInstance.Name = "Download.exe" Then
 objLatestProcess.TargetInstance.Terminate()
 End If
Loop

Im folgenden VBScript-Codebeispiel wird eine Verbindung mit einem Remotecomputer hergestellt und Notepad.exe auf diesem Computer beendet.

strComputer = "FullComputerName" 
strDomain = "DOMAIN" 
strUser = InputBox("Enter user name") 
strPassword = InputBox("Enter password") 
Set objSWbemLocator = CreateObject("WbemScripting.SWbemLocator") 
Set objWMIService = objSWbemLocator.ConnectServer(strComputer, _ 
    "root\CIMV2", _ 
    strUser, _ 
    strPassword, _ 
    "MS_409", _ 
    "ntlmdomain:" + strDomain) 
Set colProcessList = objWMIService.ExecQuery("SELECT * FROM Win32_Process WHERE Name = 'notepad.exe'")
For Each objProcess in colProcessList
    objProcess.Terminate()
Next

Der folgende C++-Code beendet den Notepad.exe Prozess auf dem lokalen Computer. Geben Sie im Code ein - oder ein Prozesshandle (Prozess-ID) an, um den Prozess zu beenden. Dieser Wert befindet sich in der handle-Eigenschaft in der Win32_Process-Klasse (die Schlüsseleigenschaft für die Klasse). Indem Sie einen Wert für die Handle-Eigenschaft angeben, geben Sie einen Pfad zum instance der Klasse an, die Sie beenden möchten. Weitere Informationen zum Herstellen einer Verbindung mit einem Remotecomputer finden Sie unter Beispiel: Abrufen von WMI-Daten von einem Remotecomputer.

#define _WIN32_DCOM

#include <iostream>
using namespace std;
#include <comdef.h>
#include <Wbemidl.h>

#pragma comment(lib, "wbemuuid.lib")

int main(int iArgCnt, char ** argv)
{
    HRESULT hres;

    // Step 1: --------------------------------------------------
    // Initialize COM. ------------------------------------------

    hres =  CoInitializeEx(0, COINIT_MULTITHREADED); 
    if (FAILED(hres))
    {
        cout << "Failed to initialize COM library. Error code = 0x" 
             << hex << hres << endl;
        return 1;                  // Program has failed.
    }

    // Step 2: --------------------------------------------------
    // Set general COM security levels --------------------------
    // Note: If you are using Windows 2000, specify -
    // the default authentication credentials for a user by using
    // a SOLE_AUTHENTICATION_LIST structure in the pAuthList ----
    // parameter of CoInitializeSecurity ------------------------

    hres =  CoInitializeSecurity(
        NULL, 
        -1,                          // COM negotiates service
        NULL,                        // Authentication services
        NULL,                        // Reserved
        RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication 
        RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation  
        NULL,                        // Authentication info
        EOAC_NONE,                   // Additional capabilities 
        NULL                         // Reserved
        );

                      
    if (FAILED(hres))
    {
        cout << "Failed to initialize security. Error code = 0x" 
             << hex << hres << endl;
        CoUninitialize();
        return 1;                      // Program has failed.
    }
    
    // Step 3: ---------------------------------------------------
    // Obtain the initial locator to WMI -------------------------

    IWbemLocator *pLoc = NULL;

    hres = CoCreateInstance(
        CLSID_WbemLocator,             
        0, 
        CLSCTX_INPROC_SERVER, 
        IID_IWbemLocator, (LPVOID *) &pLoc);
 
    if (FAILED(hres))
    {
        cout << "Failed to create IWbemLocator object. "
             << "Err code = 0x"
             << hex << hres << endl;
        CoUninitialize();
        return 1;                 // Program has failed.
    }

    // Step 4: ---------------------------------------------------
    // Connect to WMI through the IWbemLocator::ConnectServer method

    IWbemServices *pSvc = NULL;
 
    // Connect to the local root\cimv2 namespace
    // and obtain pointer pSvc to make IWbemServices calls.
    hres = pLoc->ConnectServer(
        _bstr_t(L"ROOT\\CIMV2"), 
        NULL,
        NULL, 
        0, 
        NULL, 
        0, 
        0, 
        &pSvc
    );
     
    if (FAILED(hres))
    {
        cout << "Could not connect. Error code = 0x" 
             << hex << hres << endl;
        pLoc->Release();
        pSvc->Release();     
        CoUninitialize();
        return 1;                // Program has failed.
    }

    cout << "Connected to ROOT\\CIMV2 WMI namespace" << endl;


    // Step 5: --------------------------------------------------
    // Set security levels for the proxy ------------------------

    hres = CoSetProxyBlanket(
        pSvc,                        // Indicates the proxy to set
        RPC_C_AUTHN_WINNT,           // RPC_C_AUTHN_xxx 
        RPC_C_AUTHZ_NONE,            // RPC_C_AUTHZ_xxx 
        NULL,                        // Server principal name 
        RPC_C_AUTHN_LEVEL_CALL,      // RPC_C_AUTHN_LEVEL_xxx 
        RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
        NULL,                        // client identity
        EOAC_NONE                    // proxy capabilities 
    );

    if (FAILED(hres))
    {
        cout << "Could not set proxy blanket. Error code = 0x" 
             << hex << hres << endl;
        pSvc->Release();
        pLoc->Release();     
        CoUninitialize();
        return 1;               // Program has failed.
    }

    // Step 6: --------------------------------------------------
    // Use the IWbemServices pointer to make requests of WMI ----

    // Set up to call the Win32_Process::Create method
    BSTR ClassName = SysAllocString(L"Win32_Process");

    /* YOU NEED TO CHANGE THE NUMBER VALUE OF THE HANDLE 
       (PROCESS ID) TO THE CORRECT VALUE OF THE PROCESS YOU 
       ARE TRYING TO TERMINATE (this provides a path to
       the class instance you are tying to terminate). */
    BSTR ClassNameInstance = SysAllocString(
        L"Win32_Process.Handle=\"3168\"");

    _bstr_t MethodName = (L"Terminate");
    BSTR ParameterName = SysAllocString(L"Reason");

    IWbemClassObject* pClass = NULL;
    hres = pSvc->GetObject(ClassName, 0, NULL, &pClass, NULL);

    IWbemClassObject* pInParamsDefinition = NULL;
    IWbemClassObject* pOutMethod = NULL;
    hres = pClass->GetMethod(MethodName, 0, 
        &pInParamsDefinition, &pOutMethod);

    if (FAILED(hres))
    {
        cout << "Could not get the method. Error code = 0x" 
             << hex << hres << endl;
    }

    IWbemClassObject* pClassInstance = NULL;
    hres = pInParamsDefinition->SpawnInstance(0, &pClassInstance);

    // Create the values for the in parameters
    VARIANT pcVal;
    VariantInit(&pcVal);
    V_VT(&pcVal) = VT_I4;

    // Store the value for the in parameters
    hres = pClassInstance->Put(L"Reason", 0,
        &pcVal, 0);

    // Execute Method
    hres = pSvc->ExecMethod(ClassNameInstance, MethodName, 0,
    NULL, pClassInstance, NULL, NULL);

    if (FAILED(hres))
    {
        cout << "Could not execute method. Error code = 0x" 
             << hex << hres << endl;
        VariantClear(&pcVal);
        SysFreeString(ClassName);
        SysFreeString(MethodName);
        pClass->Release();
        pInParamsDefinition->Release();
        pSvc->Release();
        pLoc->Release();     
        CoUninitialize();
        return 1;           // Program has failed.
    }


    // Clean up
    //--------------------------
    VariantClear(&pcVal);
    SysFreeString(ClassName);
    SysFreeString(MethodName);
    pClass->Release();
    pInParamsDefinition->Release();
    pLoc->Release();
    pSvc->Release();
    CoUninitialize();
    return 0;
}

Anforderungen

Anforderung Wert
Unterstützte Mindestversion (Client)
Windows Vista
Unterstützte Mindestversion (Server)
WindowsServer 2008
Namespace
Root\CIMV2
MOF
CIMWin32.mof
DLL
CIMWin32.dll

Siehe auch

Betriebssystemklassen

Win32_Process

WMI-Aufgaben: Leistungsüberwachung

WMI-Aufgaben: Prozesse