Feladatok támogatása

Ez a példa bemutatja, hogyan támogathatja a feladatokat parancsmagok írásakor. Ha azt szeretné, hogy a felhasználók háttér-feladatként futtassanak egy parancsmagot, bele kell foglalnia az alábbi eljárásban leírt kódot. További információ a háttér feladatokról: Háttér feladatok.

Feladatok támogatása

1. Definiálhat egy kapcsolóparamétert, hogy a felhasználó eldöntse, hogy a parancsmagot feladatként AsJob futtatja-e.

   Az alábbi példa egy AsJob paraméterdeklarációt mutat be.

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

2. Hozzon létre egy objektumot, amely a System.Management.Automation.Job osztályból származik. Ez az objektum lehet egy egyéni feladatobjektum vagy egy, a Windows PowerShell által biztosított feladatobjektum, például System.Management.Automation.Pseventjob objektum.

   Az alábbi példa egy egyéni feladatobjektumot mutat be.

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

3. Rekordfeldolgozási metódusban adjon hozzá egy utasítást, amely észleli, hogy a parancsmagnak feladatként if kell-e futnia. A következő kód a System.Management.Automation.Cmdlet.ProcessRecord metódust használja.

   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. Egyéni feladatobjektumok esetén implementálja a feladatosztályt.

   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. Ha a parancsmag elvégzi a munkát, hívja meg a System.Management.Automation.Cmdlet.WriteObject metódust, hogy visszaadja a folyamatobjektumot a folyamatnak. Ha a feladatot feladatként végzi el, adja hozzá a gyermek feladatot.

   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.
   

Példa

Az alábbi mintakód egy olyan parancsmag kódját mutatja be, amely belsőleg vagy háttérfolyamat használatával képes Get-Proc folyamatokat lekérni.

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
}