StopProcessSample01-Beispiel

Artikel
09/27/2021

In diesem Beispiel wird gezeigt, wie Sie ein Cmdlet schreiben, das Feedback vom Benutzer angibt, bevor er versucht, einen Prozess zu beenden, und wie ein Parameter implementiert wird, der angibt, dass der Benutzer möchte, dass das Cmdlet ein Objekt PassThru zurückgibt. Dieses Cmdlet ähnelt dem von Windows PowerShell Stop-Process 2.0 bereitgestellten Cmdlet.

Erstellen des Beispiels mithilfe Visual Studio.

Wenn das Windows PowerShell 2.0 SDK installiert ist, navigieren Sie zum Ordner StopProcessSample01. Der Standardspeicherort ist C:\Programme (x86)\Microsoft SDKs\Windows\v7.0\Samples\sysmgmt\WindowsPowerShell\csharp\StopProcessSample01.
Doppelklicken Sie auf das Symbol für die Projektmappendatei (SLN). Dadurch wird das Beispielprojekt in Microsoft Visual Studio.
Wählen Sie im Menü Erstellen die Option Projektmappe erstellen aus.

Die Bibliothek für das Beispiel wird in den Standardordnern \bin oder \bin\debug erstellt.

Ausführen des Beispiels

Erstellen Sie den folgenden Modulordner:

[user]/documents/windowspowershell/modules/StopProcessSample01
Kopieren Sie die Beispiel-Assembly in den Modulordner.
Starten Sie Windows PowerShell.
Führen Sie den folgenden Befehl aus, um die Assembly in Windows PowerShell:

import-module stopprossessample01
Führen Sie den folgenden Befehl aus, um das Cmdlet auszuführen:

stop-proc

Anforderungen

Dieses Beispiel erfordert Windows PowerShell 2.0.

Zeigt

In diesem Beispiel wird Folgendes veranschaulicht:

Deklarieren einer Cmdlet-Klasse mithilfe des Cmdlet-Attributs.
Deklarieren von Cmdlet-Parametern mithilfe des Parameter-Attributs.
Aufrufen der ShouldProcess-Methode zum Anfordern der Bestätigung.
Implementieren eines PassThru Parameters, der angibt, ob der Benutzer möchte, dass das Cmdlet ein Objekt zurückgibt. Standardmäßig gibt dieses Cmdlet kein Objekt an die Pipeline zurück.

Beispiel

In diesem Beispiel wird gezeigt, wie ein Parameter implementiert wird, der angibt, dass der Benutzer möchte, dass das Cmdlet ein Objekt zurückgibt, und wie Benutzerfeedback durch Aufrufe der Methoden und PassThru ShouldProcess anfordern ShouldContinue wird.

using System;
using System.Diagnostics;
using System.Collections;
using Win32Exception = System.ComponentModel.Win32Exception;
using System.Management.Automation;    // Windows PowerShell namespace
using System.Globalization;

namespace Microsoft.Samples.PowerShell.Commands
{
   #region StopProcCommand

    /// <summary>
   /// This class implements the stop-proc cmdlet.
   /// </summary>
   [Cmdlet(VerbsLifecycle.Stop, "Proc",
       SupportsShouldProcess = true)]
   public class StopProcCommand : Cmdlet
   {
       #region Parameters

      /// <summary>
      /// This parameter provides the list of process names on
      /// which the Stop-Proc cmdlet will work.
      /// </summary>
       [Parameter(
          Position = 0,
          Mandatory = true,
          ValueFromPipeline = true,
          ValueFromPipelineByPropertyName = true
       )]
       public string[] Name
       {
           get { return processNames; }
           set { processNames = value; }
       }
       private string[] processNames;

       /// <summary>
       /// This parameter overrides the ShouldContinue call to force
       /// the cmdlet to stop its operation. This parameter should always
       /// be used with caution.
       /// </summary>
       [Parameter]
       public SwitchParameter Force
       {
           get { return force; }
           set { force = value; }
       }
       private bool force;

       /// <summary>
       /// This parameter indicates that the cmdlet should return
       /// an object to the pipeline after the processing has been
       /// completed.
       /// </summary>
       [Parameter]
       public SwitchParameter PassThru
       {
           get { return passThru; }
           set { passThru = value; }
       }
       private bool passThru;

       #endregion Parameters

       #region Cmdlet Overrides

       /// <summary>
       /// The ProcessRecord method does the following for each of the
       /// requested process names:
       /// 1) Check that the process is not a critical process.
       /// 2) Attempt to stop that process.
       /// If no process is requested then nothing occurs.
       /// </summary>
       protected override void ProcessRecord()
       {
           foreach (string name in processNames)
           {
               // For every process name passed to the cmdlet, get the associated
               // processes.
               // Write a nonterminating error for failure to retrieve
               // a process.
               Process[] processes;

               try
               {
                   processes = Process.GetProcessesByName(name);
               }
               catch (InvalidOperationException ioe)
               {
                   WriteError(new ErrorRecord(ioe,"UnableToAccessProcessByName",
                       ErrorCategory.InvalidOperation, name));

                   continue;
               }

               // Try to stop the processes that have been retrieved.
               foreach (Process process in processes)
               {
                   string processName;

                   try
                   {
                       processName = process.ProcessName;
                   }
                   catch (Win32Exception e)
                   {
                      WriteError(new ErrorRecord(e, "ProcessNameNotFound",
                                           ErrorCategory.ReadError, process));
                      continue;
                   }

                   // Confirm the operation with the user first.
                   // This is always false if the WhatIf parameter is set.
                   if (!ShouldProcess(string.Format(CultureInfo.CurrentCulture,"{0} ({1})", processName,
                               process.Id)))
                   {
                       continue;
                   }

                   // Make sure that the user really wants to stop a critical
                   // process that could possibly stop the computer.
                   bool criticalProcess =
                       criticalProcessNames.Contains(processName.ToLower(CultureInfo.CurrentCulture));

                   if (criticalProcess &&!force)
                   {
                       string message = String.Format
                           (CultureInfo.CurrentCulture,
                                "The process \"{0}\" is a critical process and should not be stopped. Are you sure you wish to stop the process?",
                                    processName);

                       // It is possible that the ProcessRecord method is called
                       // multiple times when objects are received as inputs from
                       // the pipeline. So to retain YesToAll and NoToAll input that
                       // the user may enter across multiple calls to this function,
                       // they are stored as private members of the cmdlet.
                       if (!ShouldContinue(message, "Warning!",
                                               ref yesToAll, ref noToAll))
                       {
                           continue;
                       }
                   } // if (criticalProcess...

                   // Stop the named process.
                   try
                   {
                       process.Kill();
                   }
                   catch (Exception e)
                   {
                       if ((e is Win32Exception) || (e is SystemException) ||
                          (e is InvalidOperationException))
                       {
                           // This process could not be stopped so write
                           // a nonterminating error.
                           WriteError(new ErrorRecord(e, "CouldNotStopProcess",
                                           ErrorCategory.CloseError, process));
                           continue;
                       } // if ((e is...
                       else throw;
                   } // catch

                   // If the PassThru parameter is
                   // specified, return the terminated process.
                   if (passThru)
                   {
                       WriteObject(process);
                   }
               } // foreach (Process...
           } // foreach (string...
       } // ProcessRecord

       #endregion Cmdlet Overrides

       #region Private Data

       private bool yesToAll, noToAll;

       /// <summary>
       /// Partial list of critical processes that should not be
       /// stopped.  Lower case is used for case insensitive matching.
       /// </summary>
       private ArrayList criticalProcessNames = new ArrayList(
          new string[] { "system", "winlogon", "spoolsv" }
       );

       #endregion Private Data

   } // StopProcCommand

   #endregion StopProcCommand
}

Weitere Informationen

Schreiben eines Windows PowerShell-Cmdlets

Freigeben über