Guide pratique pour prendre en charge les travaux

Cet exemple montre comment prendre en charge les travaux lorsque vous écrivez des applets de commande. Si vous souhaitez que les utilisateurs exécutent votre applet de commande en tant que travail en arrière-plan, vous devez inclure le code décrit dans la procédure suivante. Pour plus d’informations sur les travaux en arrière-plan, consultez travaux en arrière-plan.

Pour prendre en charge les travaux

1. Définissez un paramètre de commutateur AsJob afin que l’utilisateur puisse décider s’il faut exécuter l’applet de commande en tant que travail.

   L’exemple suivant montre une déclaration de paramètre AsJob.

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

2. Créez un objet qui dérive de la classe System.Management.Automation.Job. Cet objet peut être un objet de travail personnalisé ou l’un des objets de travail fournis par Windows PowerShell, tel System.Management.Automation.PSEventJob objet.

   L’exemple suivant montre un objet de travail personnalisé.

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

3. Dans une méthode de traitement des enregistrements, ajoutez une instruction if pour détecter si l’applet de commande doit s’exécuter en tant que travail. Le code suivant utilise la méthode 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. Pour les objets de travail personnalisés, implémentez la classe de travail.

   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. Si l’applet de commande effectue le travail, appelez la méthode System.Management.Automation.Cmdlet.WriteObject pour renvoyer un objet de processus au pipeline. Si le travail est effectué en tant que travail, ajoutez un travail enfant au travail.

   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.
   

Exemple :

L’exemple de code suivant montre le code d’une applet de commande Get-Proc qui peut récupérer des processus en interne ou à l’aide d’un travail en arrière-plan.

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
}