Cmdlet-reeksen

Wanneer u uw cmdlets ontwerpt, kunnen er gevallen optreden waarin u verschillende acties moet uitvoeren op hetzelfde gegevensgetal. U moet bijvoorbeeld gegevens op halen en instellen of een proces starten en stoppen. Hoewel u afzonderlijke cmdlets moet maken om elke actie uit te voeren, moet uw cmdlet-ontwerp een basisklasse bevatten waarvan de klassen voor de afzonderlijke cmdlets zijn afgeleid.

Houd rekening met de volgende zaken bij het implementeren van een basisklasse.

• Declareer algemene parameters die worden gebruikt door alle afgeleide cmdlets in de basisklasse.

• Cmdlet-specifieke parameters toevoegen aan de juiste cmdlet-klasse.

• Overschrijven de juiste invoerverwerkingsmethode in de basisklasse.

• Declareer het kenmerk System.Management.Automation.CmdletAttribute op alle cmdlet-klassen, maar declareer het niet op de basisklasse.

• Implementeert een System.Management.Automation.PSSnapIn- of System.Management.Automation.Custompssnapin-klasse waarvan de naam en beschrijving de set cmdlets weerspiegelen.

Voorbeeld

In het volgende voorbeeld ziet u de implementatie van een basisklasse die wordt gebruikt door Get-Proc en Stop-Proc cmdlet die is afgeleid van dezelfde basisklasse.

using System;
using System.Diagnostics;
using System.Management.Automation;             //Windows PowerShell namespace.

namespace Microsoft.Samples.PowerShell.Commands
{

  #region ProcessCommands

  /// <summary>
  /// This class implements a Stop-Proc cmdlet. The parameters
  /// for this cmdlet are defined by the BaseProcCommand class.
  /// </summary>
  [Cmdlet(VerbsLifecycle.Stop, "Proc", SupportsShouldProcess = true)]
  public class StopProcCommand : BaseProcCommand
  {
    public override void ProcessObject(Process process)
    {
      if (ShouldProcess(process.ProcessName, "Stop-Proc"))
      {
        process.Kill();
      }
    }
  }

  /// <summary>
  /// This class implements a Get-Proc cmdlet. The parameters
  /// for this cmdlet are defined by the BaseProcCommand class.
  /// </summary>

  [Cmdlet(VerbsCommon.Get, "Proc")]
  public class GetProcCommand : BaseProcCommand
  {
    public override void ProcessObject(Process process)
    {
      WriteObject(process);
    }
  }

  /// <summary>
  /// This class is the base class that defines the common
  /// functionality used by the Get-Proc and Stop-Proc
  /// cmdlets.
  /// </summary>
  public class BaseProcCommand : Cmdlet
  {
    #region Parameters

    // Defines the Name parameter that is used to
    // specify a process by its name.
    [Parameter(
               Position = 0,
               Mandatory = true,
               ValueFromPipeline = true,
               ValueFromPipelineByPropertyName = true
    )]
    public string[] Name
    {
      get { return processNames; }
      set { processNames = value; }
    }
    private string[] processNames;

    // Defines the Exclude parameter that is used to
    // specify which processes should be excluded when
    // the cmdlet performs its action.
    [Parameter()]
    public string[] Exclude
    {
      get { return excludeNames; }
      set { excludeNames = value; }
    }
    private string[] excludeNames = new string[0];
    #endregion Parameters

    public virtual void ProcessObject(Process process)
    {
      throw new NotImplementedException("This method should be overridden.");
    }

    #region Cmdlet Overrides
    // <summary>
    // For each of the requested process names, retrieve and write
    // the associated processes.
    // </summary>
    protected override void ProcessRecord()
    {
      // Set up the wildcard characters used in resolving
      // the process names.
      WildcardOptions options = WildcardOptions.IgnoreCase |
                                WildcardOptions.Compiled;

      WildcardPattern[] include = new WildcardPattern[Name.Length];
      for (int i = 0; i < Name.Length; i++)
      {
        include[i] = new WildcardPattern(Name[i], options);
      }

      WildcardPattern[] exclude = new WildcardPattern[Exclude.Length];
      for (int i = 0; i < Exclude.Length; i++)
      {
        exclude[i] = new WildcardPattern(Exclude[i], options);
      }

      foreach (Process p in Process.GetProcesses())
      {
        foreach (WildcardPattern wIn in include)
        {
          if (wIn.IsMatch(p.ProcessName))
          {
            bool processThisOne = true;
            foreach (WildcardPattern wOut in exclude)
            {
              if (wOut.IsMatch(p.ProcessName))
              {
                processThisOne = false;
                break;
              }
            }
            if (processThisOne)
            {
              ProcessObject(p);
            }
            break;
          }
        }
      }
    }
    #endregion Cmdlet Overrides
  }
    #endregion ProcessCommands
}

Zie ook

Een Windows PowerShell-cmdlet schrijven