Taken ondersteunen

In dit voorbeeld ziet u hoe u taken kunt ondersteunen wanneer u cmdlets schrijft. Als u wilt dat gebruikers uw cmdlet uitvoeren als achtergrondtaak, moet u de code opnemen die in de volgende procedure wordt beschreven. Zie Achtergrondtakenvoor meer informatie over achtergrondtaken.

Taken ondersteunen

1. Definieer een AsJob switchparameter zodat de gebruiker kan bepalen of de cmdlet moet worden uitgevoerd als een taak.

   In het volgende voorbeeld ziet u een AsJob-parameterdeclaratie.

   [Parameter()]
   public SwitchParameter AsJob
   {
     get { return asjob; }
     set { asjob = value; }
   }
   private bool asjob;
   

2. Maak een object dat is afgeleid van de klasse System.Management.Automation. Job. Dit object kan een aangepast taakobject zijn of een van de taakobjecten die worden geleverd door Windows PowerShell, zoals een System.Management.Automation.PSEventJob-object.

   In het volgende voorbeeld ziet u een aangepast taakobject.

   private SampleJob job = new SampleJob("Get-ProcAsJob");
   

3. Voeg in een recordverwerkingsmethode een if instructie toe om te detecteren of de cmdlet moet worden uitgevoerd als een taak. De volgende code maakt gebruik van de methode System.Management.Automation.Cmdlet.ProcessRecord.

   protected override void ProcessRecord()
   {
     if (asjob)
     {
       // Add the job definition to the job repository,
       // return the job object, and then create the thread
       // used to run the job.
       JobRepository.Add(job);
       WriteObject(job);
       ThreadPool.QueueUserWorkItem(WorkItem);
     }
     else
     {
       job.ProcessJob();
       foreach (PSObject p in job.Output)
       {
         WriteObject(p);
       }
     }
   }
   

4. Implementeer de taakklasse voor aangepaste taakobjecten.

   private class SampleJob : Job
   {
     internal SampleJob(string command)
         : base(command)
     {
       SetJobState(JobState.NotStarted);
     }
     public override string StatusMessage
     {
       get { throw new NotImplementedException(); }
     }
   
     public override bool HasMoreData
     {
       get
       {
         return hasMoreData;
       }
     }
     private bool hasMoreData = true;
   
     public override string Location
     {
       get { throw new NotImplementedException(); }
     }
   
     public override void StopJob()
     {
       throw new NotImplementedException();
     }
   
     internal void ProcessJob()
     {
       SetJobState(JobState.Running);
       DoProcessLogic();
       SetJobState(JobState.Completed);
     }
   
     // Retrieve the processes of the local computer.
     void DoProcessLogic()
     {
       Process[] p = Process.GetProcesses();
   
       foreach (Process pl in p)
       {
         Output.Add(PSObject.AsPSObject(pl));
       }
       Output.Complete();
     } // End DoProcessLogic.
   } // End SampleJob class.
   

5. Als de cmdlet het werk uitvoert, roept u de methode System.Management.Automation.Cmdlet.WriteObject aan om een procesobject naar de pijplijn te retourneren. Als het werk wordt uitgevoerd als een taak, voegt u een onderliggende taak toe aan de taak.

   void DoProcessLogic(bool asJob)
   {
     Process[] p = Process.GetProcesses();
   
     foreach (Process pl in p)
     {
       if (!asjob)
       {
         WriteObject(pl);
       }
       else
       {
         job.ChildJobs[0].Output.Add(PSObject.AsPSObject(pl));
       }
     }
   } // End DoProcessLogic.
   

Voorbeeld

In de volgende voorbeeldcode ziet u de code voor een Get-Proc-cmdlet waarmee processen intern of met behulp van een achtergrondtaak kunnen worden opgehaald.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Management.Automation;  // Windows PowerShell namespace.
using System.Threading;              // Thread pool namespace for posting work.
using System.Diagnostics;            // Diagnostics namespace for retrieving
                                     // process objects.

// This sample shows a cmdlet whose work can be done by the cmdlet or by using
// a background job. Background jobs are executed in their own thread,
// independent of the pipeline thread in which the cmdlet is executed.
//
// To load this cmdlet, create a module folder and copy the GetProcessSample06.dll
// assembly into the module folder. Make sure that the path to the module folder
// is added to the $PSModulePath environment variable.
// Module folder path:
//    user/documents/WindowsPowerShell/modules/GetProcessSample06
//
// To import the module, run the following command: Import-Module GetProcessSample06.
// To test the cmdlet, run the following command: Get-Proc -Name <process name>
//

//
namespace Microsoft.Samples.PowerShell.Commands
{
  /// <summary>
  ///  This cmdlet retrieves process internally or returns
  ///  a job that retrieves the processes.
  /// </summary>
  [Cmdlet(VerbsCommon.Get, "Proc")]
  public sealed class GetProcCommand : PSCmdlet
  {

    #region Parameters
    /// <summary>
    /// Specify the Name parameter. This parameter accepts
    /// process names from the command line.
    /// </summary>
    [Parameter(
               Position = 0,
               ValueFromPipeline = true,
               ValueFromPipelineByPropertyName = true)]
    [ValidateNotNullOrEmpty]
    public string[] Name
    {
      get { return processNames; }
      set { processNames = value; }
    }
    private string[] processNames;

    /// <summary>
    /// Specify the AsJob parameter. This parameter indicates
    /// whether the cmdlet should retrieve the processes internally
    /// or return a Job object that retrieves the processes.
    /// </summary>
    [Parameter()]
    public SwitchParameter AsJob
    {
      get { return asjob; }
      set { asjob = value; }
    }
    private bool asjob;

    #endregion Parameters

    #region Cmdlet Overrides

    // Create a custom job object.
    private SampleJob job = new SampleJob("Get-ProcAsJob");

    /// <summary>
    /// Determines if the processes should be retrieved
    /// internally or if a Job object should be returned.
    /// </summary>
    protected override void ProcessRecord()
    {
      if (asjob)
      {
        // Add the job definition to the job repository,
        // return the job object, and then create the thread
        // used to run the job.
        JobRepository.Add(job);
        WriteObject(job);
        ThreadPool.QueueUserWorkItem(WorkItem);
      }
      else
      {
        job.ProcessJob();
        foreach (PSObject p in job.Output)
        {
          WriteObject(p);
        }
      }
    }
    #endregion Overrides

    // Implement a custom job that derives
    // from the System.Management.Automation.Job class.
    private class SampleJob : Job
    {
      internal SampleJob(string command)
          : base(command)
      {
        SetJobState(JobState.NotStarted);
      }
      public override string StatusMessage
      {
        get { throw new NotImplementedException(); }
      }

      public override bool HasMoreData
      {
        get
        {
          return hasMoreData;
        }
      }
      private bool hasMoreData = true;

      public override string Location
      {
        get { throw new NotImplementedException(); }
      }

      public override void StopJob()
      {
        throw new NotImplementedException();
      }

      internal void ProcessJob()
      {
        SetJobState(JobState.Running);
        DoProcessLogic();
        SetJobState(JobState.Completed);
      }

      // Retrieve the processes of the local computer.
      void DoProcessLogic()
      {
        Process[] p = Process.GetProcesses();

        foreach (Process pl in p)
        {
          Output.Add(PSObject.AsPSObject(pl));
        }
        Output.Complete();
      } // End DoProcessLogic.
    } // End SampleJob class.

    void WorkItem(object dummy)
    {
       job.ProcessJob();
    }

    // Display the results of the work. If not a job,
    // process objects are returned. If a job, the
    // output is added to the job as a child job.
    void DoProcessLogic(bool asJob)
    {
      Process[] p = Process.GetProcesses();

      foreach (Process pl in p)
      {
        if (!asjob)
        {
          WriteObject(pl);
        }
        else
        {
          job.ChildJobs[0].Output.Add(PSObject.AsPSObject(pl));
        }
      }
    } // End DoProcessLogic.
  } //End GetProcCommand
}