Rendszermódosító parancsmag létrehozásaCreating a Cmdlet that Modifies the System

Előfordulhat, hogy egy parancsmagnak módosítania kell a rendszer futó állapotát, nem csak a Windows PowerShell futtatókörnyezet állapotát.Sometimes a cmdlet must modify the running state of the system, not just the state of the Windows PowerShell runtime. Ezekben az esetekben a parancsmagnak lehetővé kell tennie a felhasználó számára, hogy megerősítse a módosítást.In these cases, the cmdlet should allow the user a chance to confirm whether or not to make the change.

A megerősítéshez a parancsmagnak két dolgot kell tennie.To support confirmation a cmdlet must do two things.

A megerősítés támogatásával a parancsmag a Confirm WhatIf Windows PowerShell által biztosított és paramétereket teszi elérhetővé, és megfelel a parancsmagokra vonatkozó fejlesztési irányelveknek (a parancsmagok fejlesztési iránymutatásaival kapcsolatos további információkért lásd: parancsmag-fejlesztési irányelvek).By supporting confirmation, a cmdlet exposes the Confirm and WhatIf parameters that are provided by Windows PowerShell, and also meets the development guidelines for cmdlets (For more information about cmdlet development guidelines, see Cmdlet Development Guidelines.).

A szolgáltatás módosításaChanging the System

A "rendszer módosítása" eljárás olyan parancsmagra hivatkozik, amely potenciálisan megváltoztatja a rendszer állapotát a Windows PowerShellen kívül.The act of "changing the system" refers to any cmdlet that potentially changes the state of the system outside Windows PowerShell. Például egy folyamat leállítása, egy felhasználói fiók engedélyezése vagy letiltása, illetve sorok hozzáadása egy adatbázis-táblához a rendszer minden olyan változása, amelyet meg kell erősíteni.For example, stopping a process, enabling or disabling a user account, or adding a row to a database table are all changes to the system that should be confirmed. Ezzel szemben az adatok olvasását vagy átmeneti kapcsolatokat létesíteni kívánó műveletek nem módosítják a rendszert, és általában nem igényelnek megerősítést.In contrast, operations that read data or establish transient connections do not change the system and generally do not require confirmation. A megerősítés nem szükséges olyan műveletekhez, amelyek hatása a Windows PowerShell-futtatókörnyezeten belülre korlátozódik, például: set-variable .Confirmation is also not needed for actions whose effect is limited to inside the Windows PowerShell runtime, such as set-variable. Azok a parancsmagok, amelyek esetleg nem állandó módosítást tesznek lehetővé, deklarálják SupportsShouldProcess és meghívhatják a System. Management. Automation. parancsmag. ShouldProcess csak akkor, ha állandó módosítást végeznek.Cmdlets that might or might not make a persistent change should declare SupportsShouldProcess and call System.Management.Automation.Cmdlet.ShouldProcess only if they are about to make a persistent change.

Megjegyzés

A ShouldProcess megerősítése csak a parancsmagokra vonatkozik.ShouldProcess confirmation applies only to cmdlets. Ha egy parancs vagy parancsfájl módosítja egy rendszer futó állapotát a .NET-metódusok vagy-tulajdonságok közvetlen meghívásával, vagy a Windows PowerShellen kívüli alkalmazások meghívásával, akkor ez a megerősítési űrlap nem lesz elérhető.If a command or script modifies the running state of a system by directly calling .NET methods or properties, or by calling applications outside of Windows PowerShell, this form of confirmation will not be available.

Az StopProc-parancsmagThe StopProc Cmdlet

Ez a témakör egy leállítás utáni parancsmagot ismertet, amely megkísérli leállítani a Get-proc parancsmag használatával lekért folyamatokat (az első parancsmag létrehozásacímű témakörben leírtak szerint).This topic describes a Stop-Proc cmdlet that attempts to stop processes that are retrieved using the Get-Proc cmdlet (described in Creating Your First Cmdlet).

A parancsmag meghatározásaDefining the Cmdlet

A parancsmag létrehozásának első lépése mindig a parancsmag elnevezése, és a parancsmagot implementáló .NET-osztály deklarálása.The first step in cmdlet creation is always naming the cmdlet and declaring the .NET class that implements the cmdlet. Mivel a rendszer módosításához parancsmagot írunk, azt ennek megfelelően kell megnevezni.Because you are writing a cmdlet to change the system, it should be named accordingly. Ez a parancsmag leállítja a rendszerfolyamatokat, így az itt választott művelet "Leállítás", a System. Management. Automation. Verbslifecycle osztály, a "proc" kifejezéssel megadva, jelezve, hogy a parancsmag leállítja a folyamatokat.This cmdlet stops system processes, so the verb name chosen here is "Stop", defined by the System.Management.Automation.Verbslifecycle class, with the noun "Proc" to indicate that the cmdlet stops processes. További információ a jóváhagyott parancsmag-műveletekről: parancsmag-műveletek nevei.For more information about approved cmdlet verbs, see Cmdlet Verb Names.

A következő a stop-proc parancsmag osztályának definíciója.The following is the class definition for this Stop-Proc cmdlet.

[Cmdlet(VerbsLifecycle.Stop, "Proc",
        SupportsShouldProcess = true)]
public class StopProcCommand : Cmdlet

Vegye figyelembe, hogy a System. Management. Automation. CmdletAttribute deklarációban az SupportsShouldProcess attribútum kulcsszó úgy van beállítva, hogy true engedélyezze a parancsmagnak a System. Management. Automation. parancsmag. ShouldProcess és System. Management. Automation. parancsmag. ShouldContinuehívását.Be aware that in the System.Management.Automation.CmdletAttribute declaration, the SupportsShouldProcess attribute keyword is set to true to enable the cmdlet to make calls to System.Management.Automation.Cmdlet.ShouldProcess and System.Management.Automation.Cmdlet.ShouldContinue. A kulcsszó nélkül a és a Confirm WhatIf paraméterek nem lesznek elérhetők a felhasználó számára.Without this keyword set, the Confirm and WhatIf parameters will not be available to the user.

Rendkívül romboló műveletekExtremely Destructive Actions

Bizonyos műveletek rendkívül romboló jellegűek, például egy aktív merevlemez-partíció újraformázása.Some operations are extremely destructive, such as reformatting an active hard disk partition. Ezekben az esetekben a parancsmagot be kell állítani ConfirmImpact = ConfirmImpact.High a System. Management. Automation. CmdletAttribute attribútum deklarálása során.In these cases, the cmdlet should set ConfirmImpact = ConfirmImpact.High when declaring the System.Management.Automation.CmdletAttribute attribute. Ez a beállítás arra kényszeríti a parancsmagot, hogy felhasználói megerősítést kérjen, még akkor is, ha a felhasználó nem adta meg a Confirm paramétert.This setting forces the cmdlet to request user confirmation even when the user has not specified the Confirm parameter. A parancsmag-fejlesztőknek azonban kerülniük kell az olyan műveletek túlhasználatát ConfirmImpact , amelyek csak potenciálisan romboló jellegűek, például egy felhasználói fiók törlése.However, cmdlet developers should avoid overusing ConfirmImpact for operations that are just potentially destructive, such as deleting a user account. Ne feledje, hogy ha ConfirmImpact a értéke System. Management. Automation. ConfirmImpact magas.Remember that if ConfirmImpact is set to System.Management.Automation.ConfirmImpact High.

Hasonlóképpen, bizonyos műveletek nem valószínű, hogy romboló jellegűek, de elméletileg módosítják egy rendszer futó állapotát a Windows PowerShellen kívül.Similarly, some operations are unlikely to be destructive, although they do in theory modify the running state of a system outside Windows PowerShell. Ilyen parancsmagok állíthatók be ConfirmImpact a System. Management. Automation. Confirmimpact. Lowértékre.Such cmdlets can set ConfirmImpact to System.Management.Automation.Confirmimpact.Low. Ez megkerüli a megerősítő kérelmeket, amelyekben a felhasználó megkérte, hogy csak közepes hatású és nagy hatású műveleteket erősítsen meg.This will bypass confirmation requests where the user has asked to confirm only medium-impact and high-impact operations.

Paraméterek definiálása a rendszer módosításáhozDefining Parameters for System Modification

Ez a szakasz azt ismerteti, hogyan határozható meg a parancsmag paraméterei, beleértve azokat is, amelyek a rendszer módosításának támogatásához szükségesek.This section describes how to define the cmdlet parameters, including those that are needed to support system modification. A paraméterek definiálásával kapcsolatos általános információkhoz tekintse meg a parancssori bemenet feldolgozásához szükséges paraméterek hozzáadását ismertető témakört.See Adding Parameters that Process CommandLine Input if you need general information about defining parameters.

A stop-proc parancsmag három paramétert határoz meg: Name , Force és PassThru .The Stop-Proc cmdlet defines three parameters: Name, Force, and PassThru.

A Name paraméter a Name Process input objektum tulajdonságának felel meg.The Name parameter corresponds to the Name property of the process input object. Ügyeljen arra, hogy a Name mintában szereplő paraméter kötelező, mivel a parancsmag sikertelen lesz, ha nem áll rendelkezésre elnevezett folyamat.Be aware that the Name parameter in this sample is mandatory, as the cmdlet will fail if it does not have a named process to stop.

A Force paraméter lehetővé teszi, hogy a felhasználó felülbírálja a rendszer. Management. Automation. parancsmag. ShouldContinuehívásait.The Force parameter allows the user to override calls to System.Management.Automation.Cmdlet.ShouldContinue. Valójában minden olyan parancsmag, amely meghívja a System. Management. Automation. parancsmagot. a ShouldContinue Force paraméterrel kell rendelkeznie, hogy ha meg Force van adva, a parancsmag kihagyja a hívást a System. Management. Automation. parancsmag. ShouldContinue , és folytatja a műveletet.In fact, any cmdlet that calls System.Management.Automation.Cmdlet.ShouldContinue should have a Force parameter so that when Force is specified, the cmdlet skips the call to System.Management.Automation.Cmdlet.ShouldContinue and proceeds with the operation. Vegye figyelembe, hogy ez nem befolyásolja a System. Management. Automation. parancsmag. ShouldProcesshívásait.Be aware that this does not affect calls to System.Management.Automation.Cmdlet.ShouldProcess.

A PassThru paraméter lehetővé teszi a felhasználó számára, hogy jelezze, hogy a parancsmag átadja-e a kimeneti objektumot a folyamaton keresztül, ebben az esetben egy folyamat leállítása után.The PassThru parameter allows the user to indicate whether the cmdlet passes an output object through the pipeline, in this case, after a process is stopped. Vegye figyelembe, hogy ez a paraméter a bemeneti objektum tulajdonsága helyett magához a parancsmaghoz van kötve.Be aware that this parameter is tied to the cmdlet itself instead of to a property of the input object.

Itt látható a stop-proc parancsmag paraméter-deklarációja.Here is the parameter declaration for the Stop-Proc cmdlet.

[Parameter(
           Position = 0,
           Mandatory = true,
           ValueFromPipeline = true,
           ValueFromPipelineByPropertyName = true
)]
public string[] Name
{
  get { return processNames; }
  set { processNames = value; }
}
private string[] processNames;

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

/// <summary>
/// Specify the PassThru parameter that allows the user to specify
/// that the cmdlet should pass the process object down the pipeline
/// after the process has been stopped.
/// </summary>
[Parameter]
public SwitchParameter PassThru
{
  get { return passThru; }
  set { passThru = value; }
}
private bool passThru;

Egy bemeneti feldolgozási módszer felülbírálásaOverriding an Input Processing Method

A parancsmagnak felül kell bírálnia egy bemeneti feldolgozási módszert.The cmdlet must override an input processing method. A következő kód bemutatja a System. Management. Automation. parancsmag. ProcessRecord felülbírálást, amelyet a mintában a stop-proc parancsmagban használtak.The following code illustrates the System.Management.Automation.Cmdlet.ProcessRecord override used in the sample Stop-Proc cmdlet. Ez a módszer biztosítja, hogy a folyamat nem egy speciális folyamat legyen, és a rendszer megpróbálja leállítani a folyamatot, majd kimeneti objektumot küld, ha a paraméter meg PassThru van adva.For each requested process name, this method ensures that the process is not a special process, tries to stop the process, and then sends an output object if the PassThru parameter is specified.

protected override void ProcessRecord()
{
  foreach (string name in processNames)
  {
    // For every process name passed to the cmdlet, get the associated
    // process(es). For failures, write a non-terminating error
    Process[] processes;

    try
    {
      processes = Process.GetProcessesByName(name);
    }
    catch (InvalidOperationException ioe)
    {
      WriteError(new ErrorRecord(ioe,"Unable to access the target process by name",
                 ErrorCategory.InvalidOperation, name));
      continue;
    }

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

      try
      {
        processName = process.ProcessName;
      }

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

        // Call Should Process to confirm the operation first.
        // This is always false if WhatIf is set.
        if (!ShouldProcess(string.Format("{0} ({1})", processName,
                           process.Id)))
        {
          continue;
        }
        // Call ShouldContinue to make sure the user really does want
        // to stop a critical process that could possibly stop the computer.
        bool criticalProcess =
             criticalProcessNames.Contains(processName.ToLower());

        if (criticalProcess &&!force)
        {
          string message = String.Format
                ("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 ProcessRecord is called multiple times
          // when the Name parameter receives objects as input from the
          // pipeline. So to retain YesToAll and NoToAll input that the
          // user may enter across multiple calls to ProcessRecord, this
          // information is 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 non-terminating error.
            string message = String.Format("{0} {1} {2}",
                             "Could not stop process \"", processName,
                             "\".");
            WriteError(new ErrorRecord(e, message,
                       ErrorCategory.CloseError, process));
                       continue;
          } // if ((e is...
          else throw;
        } // catch

        // If the PassThru parameter argument is
        // True, pass the terminated process on.
        if (passThru)
        {
          WriteObject(process);
        }
    } // foreach (Process...
  } // foreach (string...
} // ProcessRecord

A ShouldProcess metódus hívásaCalling the ShouldProcess Method

A parancsmag input Processing metódusának meg kell hívnia a System. Management. Automation. parancsmag. ShouldProcess metódust, amellyel megerősíthető egy művelet végrehajtása a módosítás előtt (például fájlok törlése) a rendszer futó állapotára.The input processing method of your cmdlet should call the System.Management.Automation.Cmdlet.ShouldProcess method to confirm execution of an operation before a change (for example, deleting files) is made to the running state of the system. Ez lehetővé teszi, hogy a Windows PowerShell-futtatókörnyezet a rendszerhéjon belül a megfelelő "WhatIf" és "Confirm" viselkedést adja meg.This allows the Windows PowerShell runtime to supply the correct "WhatIf" and "Confirm" behavior within the shell.

Megjegyzés

Ha egy parancsmag azt jelzi, hogy az általa támogatott, fel kell dolgoznia, és nem tudja végrehajtani a System. Management. Automation. parancsmag. ShouldProcess hívást, a felhasználó váratlanul módosíthatja a rendszerét.If a cmdlet states that it supports should process and fails to make the System.Management.Automation.Cmdlet.ShouldProcess call, the user might modify the system unexpectedly.

A System. Management. Automation. parancsmag. ShouldProcess hívása elküldi a felhasználónak módosítandó erőforrás nevét, a Windows PowerShell-futtatókörnyezettel pedig figyelembe veszi a parancssori beállításokat vagy a preferencia-változókat annak meghatározásához, hogy mi jelenjen meg a felhasználónak.The call to System.Management.Automation.Cmdlet.ShouldProcess sends the name of the resource to be changed to the user, with the Windows PowerShell runtime taking into account any command-line settings or preference variables in determining what should be displayed to the user.

Az alábbi példa azt mutatja, hogy a System. Management. Automation. parancsmag. ShouldProcess a System. Management. Automation. parancsmag. ProcessRecord metódus felülbírálásával a "Stop-proc" parancsmagban található.The following example shows the call to System.Management.Automation.Cmdlet.ShouldProcess from the override of the System.Management.Automation.Cmdlet.ProcessRecord method in the sample Stop-Proc cmdlet.

if (!ShouldProcess(string.Format("{0} ({1})", processName,
                   process.Id)))
{
  continue;
}

A ShouldContinue metódus hívásaCalling the ShouldContinue Method

A System. Management. Automation. parancsmag. ShouldContinue metódus hívása másodlagos üzenetet küld a felhasználónak.The call to the System.Management.Automation.Cmdlet.ShouldContinue method sends a secondary message to the user. Ez a hívás a System. Management. Automation. parancsmag. ShouldProcess függvény hívása után történik true , és ha a Force paraméter értéke nem volt true .This call is made after the call to System.Management.Automation.Cmdlet.ShouldProcess returns true and if the Force parameter was not set to true. A felhasználó visszajelzéseket adhat arról, hogy a művelet folytatódjon-e.The user can then provide feedback to say whether the operation should be continued. A parancsmag a System. Management. Automation. parancsmag. ShouldContinue -t hívja meg a potenciálisan veszélyes rendszermódosítások további ellenőrzéséhez, vagy ha az igen-az-all és a-to-all beállítást szeretné megadni a felhasználónak.Your cmdlet calls System.Management.Automation.Cmdlet.ShouldContinue as an additional check for potentially dangerous system modifications or when you want to provide yes-to-all and no-to-all options to the user.

Az alábbi példa azt mutatja, hogy a System. Management. Automation. parancsmag. ShouldContinue a System. Management. Automation. parancsmag. ProcessRecord metódus felülbírálásával a "Stop-proc" parancsmagban található.The following example shows the call to System.Management.Automation.Cmdlet.ShouldContinue from the override of the System.Management.Automation.Cmdlet.ProcessRecord method in the sample Stop-Proc cmdlet.

if (criticalProcess &&!force)
{
  string message = String.Format
        ("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 ProcessRecord is called multiple times
  // when the Name parameter receives objects as input from the
  // pipeline. So to retain YesToAll and NoToAll input that the
  // user may enter across multiple calls to ProcessRecord, this
  // information is stored as private members of the cmdlet.
  if (!ShouldContinue(message, "Warning!",
                      ref yesToAll,
                      ref noToAll))
  {
    continue;
  }
} // if (criticalProcess...

Bemeneti feldolgozás leállításaStopping Input Processing

A rendszer-módosításokat végző parancsmag bemeneti feldolgozási módszerének meg kell adnia a bevitel feldolgozásának leállításának módját.The input processing method of a cmdlet that makes system modifications must provide a way of stopping the processing of input. Ennél a stop-proc parancsmagnál a rendszer egy hívást kezdeményez a System. Management. Automation. parancsmag. ProcessRecord metódusról a System. Diagnostics. Process. kill * metódusra.In the case of this Stop-Proc cmdlet, a call is made from the System.Management.Automation.Cmdlet.ProcessRecord method to the System.Diagnostics.Process.Kill* method. Mivel a PassThru paraméter értéke true , System. Management. Automation. parancsmag. a ProcessRecord a System. Management. Automation. parancsmag. WriteObject metódust is hívja a folyamat objektumának elküldéséhez.Because the PassThru parameter is set to true, System.Management.Automation.Cmdlet.ProcessRecord also calls System.Management.Automation.Cmdlet.WriteObject to send the process object to the pipeline.

MintakódCode Sample

A teljes C# mintakód: StopProcessSample01 minta.For the complete C# sample code, see StopProcessSample01 Sample.

Objektumtípusok és formázások definiálásaDefining Object Types and Formatting

A Windows PowerShell a parancsmagok közötti adatokat .net-objektumokkal továbbítja.Windows PowerShell passes information between cmdlets using .Net objects. Ennek következtében előfordulhat, hogy a parancsmagnak meg kell határoznia a saját típusát, vagy előfordulhat, hogy a parancsmagnak egy másik parancsmag által biztosított meglévő típust kell kiterjesztenie.Consequently, a cmdlet may need to define its own type, or the cmdlet may need to extend an existing type provided by another cmdlet. Az új típusok definiálásával vagy a meglévő típusok kiterjesztésével kapcsolatos további információkért lásd: az Objektumtípusok és a formázás kiterjesztése.For more information about defining new types or extending existing types, see Extending Object Types and Formatting.

A parancsmag felépítéseBuilding the Cmdlet

A parancsmag implementálása után a Windows PowerShell beépülő modullal kell regisztrálni a Windows PowerShellben.After implementing a cmdlet, it must be registered with Windows PowerShell through a Windows PowerShell snap-in. A parancsmagok regisztrálásával kapcsolatos további információkért lásd: parancsmagok, szolgáltatók és gazdagép-alkalmazások regisztrálása.For more information about registering cmdlets, see How to Register Cmdlets, Providers, and Host Applications.

A parancsmag teszteléseTesting the Cmdlet

Ha a parancsmag regisztrálva van a Windows PowerShellben, tesztelheti azt a parancssorban futtatva.When your cmdlet has been registered with Windows PowerShell, you can test it by running it on the command line. A stop-proc parancsmag tesztelését több teszt is végezheti.Here are several tests that test the Stop-Proc cmdlet. További információ a parancsmagok parancssorból történő használatáról: első lépések a Windows PowerShellhasználatával.For more information about using cmdlets from the command line, see the Getting Started with Windows PowerShell.

  • Indítsa el a Windows PowerShellt, és a stop-proc parancsmag használatával állítsa le a feldolgozást az alább látható módon.Start Windows PowerShell and use the Stop-Proc cmdlet to stop processing as shown below. Mivel a parancsmag kötelezőként határozza meg a Name paramétert, a parancsmag lekérdezi a paramétert.Because the cmdlet specifies the Name parameter as mandatory, the cmdlet queries for the parameter.

    PS> stop-proc
    

    A következő kimenet jelenik meg.The following output appears.

    Cmdlet stop-proc at command pipeline position 1
    Supply values for the following parameters:
    Name[0]:
    
  • Most pedig használja a parancsmagot a "Jegyzettömb" nevű folyamat leállításához.Now let's use the cmdlet to stop the process named "NOTEPAD". A parancsmag megkéri, hogy erősítse meg a műveletet.The cmdlet asks you to confirm the action.

    PS> stop-proc -Name notepad
    

    A következő kimenet jelenik meg.The following output appears.

    Confirm
    Are you sure you want to perform this action?
    Performing operation "stop-proc" on Target "notepad (4996)".
    [Y] Yes  [A] Yes to All  [N] No  [L] No to All  [S] Suspend  [?] Help (default is "Y"): Y
    
  • A "WINLOGON" nevű kritikus folyamat leállításához használja a stop-proc kifejezést.Use Stop-Proc as shown to stop the critical process named "WINLOGON". A rendszer felszólítja, és figyelmezteti a művelet elvégzésére, mert az operációs rendszer újraindítását fogja eredményezni.You are prompted and warned about performing this action because it will cause the operating system to reboot.

    PS> stop-proc -Name Winlogon
    

    A következő kimenet jelenik meg.The following output appears.

    Confirm
    Are you sure you want to perform this action?
    Performing operation "stop-proc" on Target "winlogon (656)".
    [Y] Yes  [A] Yes to All  [N] No  [L] No to All  [S] Suspend  [?] Help (default is "Y"): Y
    Warning!
    The process " winlogon " is a critical process and should not be stopped. Are you sure you wish to stop the process?
    [Y] Yes  [A] Yes to All  [N] No  [L] No to All  [S] Suspend  [?] Help (default is "Y"): N
    
  • Most próbálja meg leállítani a WINLOGON-folyamatot figyelmeztetés fogadása nélkül.Let's now try to stop the WINLOGON process without receiving a warning. Vegye figyelembe, hogy ez a parancs a Force paraméter használatával felülbírálja a figyelmeztetést.Be aware that this command entry uses the Force parameter to override the warning.

    PS> stop-proc -Name winlogon -Force
    

    A következő kimenet jelenik meg.The following output appears.

    Confirm
    Are you sure you want to perform this action?
    Performing operation "stop-proc" on Target "winlogon (656)".
    [Y] Yes  [A] Yes to All  [N] No  [L] No to All  [S] Suspend  [?] Help (default is "Y"): N
    

Lásd még:See Also

Parancssori bemenetet feldolgozó paraméterek hozzáadásaAdding Parameters that Process Command-Line Input

Objektumok típusának és formázásának kiterjesztéseExtending Object Types and Formatting

Parancsmagok, szolgáltatók és gazdagép-alkalmazások regisztrálásaHow to Register Cmdlets, Providers, and Host Applications

Windows PowerShell SDKWindows PowerShell SDK

ParancsmagmintákCmdlet Samples