StopProcessSample01 – mintaStopProcessSample01 Sample

Ez a minta bemutatja, hogyan írhat egy olyan parancsmagot, amely visszajelzést kér a felhasználótól, mielőtt megpróbálja leállítani a folyamatot, és hogyan implementálhat egy paramétert, amely azt PassThru jelzi, hogy a felhasználó a parancsmagot egy objektum visszaadására kéri.This sample shows how to write a cmdlet that requests feedback from the user before it attempts to stop a process, and how to implement a PassThru parameter indicating that the user wants the cmdlet to return an object. Ez a parancsmag hasonlít a Stop-Process Windows PowerShell 2,0 által biztosított parancsmaghoz.This cmdlet is similar to the Stop-Process cmdlet provided by Windows PowerShell 2.0.

A minta létrehozása a Visual Studio használatával.How to build the sample by using Visual Studio.

  1. Ha telepítette a Windows PowerShell 2,0 SDK-t, navigáljon a StopProcessSample01 mappára.With the Windows PowerShell 2.0 SDK installed, navigate to the StopProcessSample01 folder. Az alapértelmezett hely a C:\Program Files (x86) \Microsoft SDKs\Windows\v7.0\Samples\sysmgmt\WindowsPowerShell\csharp\StopProcessSample01.The default location is C:\Program Files (x86)\Microsoft SDKs\Windows\v7.0\Samples\sysmgmt\WindowsPowerShell\csharp\StopProcessSample01.

  2. Kattintson duplán a megoldás (. SLN) fájljának ikonjára.Double-click the icon for the solution (.sln) file. Ez megnyitja a minta projektet a Microsoft Visual Studióban.This opens the sample project in Microsoft Visual Studio.

  3. A build (létrehozás ) menüben válassza a megoldás létrehozásalehetőséget.In the Build menu, select Build Solution.

    A minta könyvtára az alapértelmezett \Bin-vagy \Bin\Debug-mappákban lesz felépítve.The library for the sample will be built in the default \bin or \bin\debug folders.

A minta futtatásaHow to run the sample

  1. Hozza létre a következő modul-mappát:Create the following module folder:

    [user]/documents/windowspowershell/modules/StopProcessSample01

  2. Másolja a minta szerelvényt a modul mappájába.Copy the sample assembly to the module folder.

  3. Indítsa el a Windows PowerShellt.Start Windows PowerShell.

  4. Futtassa a következő parancsot a szerelvény Windows PowerShellbe való betöltéséhez:Run the following command to load the assembly into Windows PowerShell:

    import-module stopprossessample01

  5. Futtassa a következő parancsot a parancsmag futtatásához:Run the following command to run the cmdlet:

    stop-proc

KövetelményekRequirements

Ehhez a mintához Windows PowerShell 2,0 szükséges.This sample requires Windows PowerShell 2.0.

Útmutató ehhez:Demonstrates

Ez a példa a következőt mutatja be.This sample demonstrates the following.

  • Parancsmag osztály deklarálása a parancsmag attribútum használatával.Declaring a cmdlet class by using the Cmdlet attribute.

  • Parancsmag paramétereinek deklarálása a Parameters attribútum használatával.Declaring a cmdlet parameters by using the Parameter attribute.

  • A ShouldProcess metódus hívása megerősítés kéréséhez.Calling the ShouldProcess method to request confirmation.

  • Olyan PassThru paraméter megvalósítása, amely azt jelzi, hogy a felhasználó szeretne-e egy objektumot visszaadni a parancsmagnak.Implementing a PassThru parameter that indicates if the user wants the cmdlet to return an object. Alapértelmezés szerint ez a parancsmag nem ad vissza objektumot a folyamatnak.By default, this cmdlet does not return an object to the pipeline.

PéldaExample

Ez a minta egy olyan paraméter megvalósítását mutatja be PassThru , amely azt jelzi, hogy a felhasználó szeretné, hogy a parancsmag egy objektumot küldjön vissza, és hogyan kérheti le a felhasználói visszajelzéseket a ShouldProcess és a ShouldContinue metódusok hívásával.This sample shows how to implement a PassThru parameter that indicates that the user wants the cmdlet to return an object, and how to request user feedback by calls to the ShouldProcess and ShouldContinue methods.

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
}

Lásd még:See Also

Windows PowerShell-parancsmag írásaWriting a Windows PowerShell Cmdlet