Jak obsługiwać zadania

W tym przykładzie pokazano, jak obsługiwać zadania podczas pisania poleceń cmdlet. Jeśli chcesz, aby użytkownicy uruchamiali polecenie cmdlet jako zadanie w tle, musisz dołączyć kod opisany w poniższej procedurze. Aby uzyskać więcej informacji na temat zadań w tle, zobacz Zadania w tle.

Aby obsługiwać zadania

1. Zdefiniuj parametr przełącznika AsJob, aby użytkownik mógł zdecydować, czy uruchomić polecenie cmdlet jako zadanie.

   W poniższym przykładzie przedstawiono deklarację parametru AsJob.

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

2. Utwórz obiekt pochodzący z klasy System.Management.Automation.Job. Ten obiekt może być obiektem zadania niestandardowego lub jednym z obiektów zadania dostarczonych przez program Windows PowerShell, na przykład obiekt System.Management.Automation.PSEventJob.

   Poniższy przykład przedstawia niestandardowy obiekt zadania.

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

3. W metodzie przetwarzania rekordów dodaj instrukcję if, aby wykryć, czy polecenie cmdlet powinno być uruchamiane jako zadanie. Poniższy kod używa metody 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. W przypadku obiektów zadań niestandardowych zaimplementuj klasę zadań.

   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. Jeśli polecenie cmdlet wykonuje pracę, wywołaj metodę System.Management.Automation.Cmdlet.WriteObject, aby zwrócić obiekt procesu do potoku. Jeśli praca jest wykonywana jako zadanie, dodaj zadanie podrzędne do zadania.

   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.
   

Przykład

Poniższy przykładowy kod przedstawia kod polecenia cmdlet Get-Proc, które może pobierać procesy wewnętrznie lub przy użyciu zadania w tle.

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
}