Opdrachten toevoegen en aanroepen

Artikel
09/25/2021
3 minuten om te lezen

Nadat u een runspace hebt gemaakt, kunt u powershell Windows commands en scripts toevoegen aan een pijplijn en vervolgens de pijplijn synchroon of asynchroon aanroepen.

Een pijplijn maken

De klasse System.Management.Automation.Powershell biedt verschillende methoden om opdrachten, parameters en scripts aan de pijplijn toe te voegen. U kunt de pijplijn synchroon aanroepen door een overload van de methode System.Management.Automation.Powershell.Invoke* aan te roepen of asynchroon door een overload van de system.Management.Automation.Powershell.Begininvoke* aan te roepen en vervolgens de methode System.Management.Automation.Powershell.Endinvoke*.

AddCommand

Maak een System.Management.Automation.Powershell-object.
```
PowerShell ps = PowerShell.Create();
```
Voeg de opdracht toe die u wilt uitvoeren.
```
ps.AddCommand("Get-Process");
```
Roep de opdracht aan.
```
ps.Invoke();
```

Als u de methode System.Management.Automation.Powershell.Addcommand* meer dan één keer aanroept voordat u de methode System.Management.Automation.Powershell.Invoke* aanroept, wordt het resultaat van de eerste opdracht doorspijpt naar de tweede, en meer. Als u het resultaat van een vorige opdracht niet wilt doorspijpen naar een opdracht, voegt u deze toe door system.Management.Automation.Powershell.Addstatement* aan te roepen.

AddParameter

In het vorige voorbeeld wordt één opdracht uitgevoerd zonder parameters. U kunt parameters toevoegen aan de opdracht met behulp van de methode System.Management.Automation.Pscommand.Addparameter*. De volgende code haalt bijvoorbeeld een lijst op met alle processen met de naam die worden uitgevoerd op de PowerShell computer.

PowerShell.Create().AddCommand("Get-Process")
                   .AddParameter("Name", "PowerShell")
                   .Invoke();

U kunt extra parameters toevoegen door System.Management.Automation.Pscommand.Addparameter* herhaaldelijk aan te roepen.

PowerShell.Create().AddCommand("Get-Command")
                   .AddParameter("Name", "Get-VM")
                   .AddParameter("Module", "Hyper-V")
                   .Invoke();

U kunt ook een woordenlijst met parameternamen en -waarden toevoegen door de methode System.Management.Automation.Powershell.Addparameters* aan te roepen.

IDictionary parameters = new Dictionary<String, String>();
parameters.Add("Name", "Get-VM");

parameters.Add("Module", "Hyper-V");
PowerShell.Create().AddCommand("Get-Command")
   .AddParameters(parameters)
      .Invoke()

AddStatement

U kunt batching simuleren met behulp van de methode System.Management.Automation.Powershell.Addstatement*, waarmee een extra instructie aan het einde van de pijplijn wordt toegevoegd. Met de volgende code wordt een lijst met lopende processen met de naam , en vervolgens de lijst met services die worden uitgevoerd, PowerShell weergegeven.

PowerShell ps = PowerShell.Create();
ps.AddCommand("Get-Process").AddParameter("Name", "PowerShell");
ps.AddStatement().AddCommand("Get-Service");
ps.Invoke();

AddScript

U kunt een bestaand script uitvoeren door de methode System.Management.Automation.Powershell.Addscript* aan te roepen. In het volgende voorbeeld wordt een script aan de pijplijn toegevoegd en uitgevoerd. In dit voorbeeld wordt ervan uitgenomen dat er al een script met de MyScript.ps1 naam is in een map met de naam D:\PSScripts .

PowerShell ps = PowerShell.Create();
ps.AddScript(File.ReadAllText(@"D:\PSScripts\MyScript.ps1")).Invoke();

Er is ook een versie van de methode System.Management.Automation.Powershell.Addscript*, die een Booleaanse parameter met de naam useLocalScope gebruikt. Als deze parameter is ingesteld op true , wordt het script uitgevoerd in het lokale bereik. Met de volgende code wordt het script uitgevoerd in het lokale bereik.

PowerShell ps = PowerShell.Create();
ps.AddScript(File.ReadAllText(@"D:\PSScripts\MyScript.ps1"), true).Invoke();

Een pijplijn synchroon aanroepen

Nadat u elementen aan de pijplijn hebt toevoegen, roept u deze aan. Als u de pijplijn synchroon wilt aanroepen, roept u een overload van de methode System.Management.Automation.Powershell.Invoke* aan. In het volgende voorbeeld ziet u hoe u een pijplijn synchroon aanroept.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Management.Automation;

namespace HostPS1e
{
  class HostPS1e
  {
    static void Main(string[] args)
    {
      // Using the PowerShell.Create and AddCommand
      // methods, create a command pipeline.
      PowerShell ps = PowerShell.Create().AddCommand ("Sort-Object");

      // Using the PowerShell.Invoke method, run the command
      // pipeline using the supplied input.
      foreach (PSObject result in ps.Invoke(new int[] { 3, 1, 6, 2, 5, 4 }))
      {
          Console.WriteLine("{0}", result);
      } // End foreach.
    } // End Main.
  } // End HostPS1e.
}

Een pijplijn asynchroon aanroepen

U roept een pijplijn asynchroon aan door een overload van de system.Management.Automation.Powershell.Begininvoke* aan te roepen om een IAsyncResult-object te maken en vervolgens de methode System.Management.Automation.Powershell.Endinvoke* aan te roepen.

In het volgende voorbeeld ziet u hoe u een pijplijn asynchroon aanroept.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Management.Automation;

namespace HostPS3
{
  class HostPS3
  {
    static void Main(string[] args)
    {
      // Use the PowerShell.Create and PowerShell.AddCommand
      // methods to create a command pipeline that includes
      // Get-Process cmdlet. Do not include spaces immediately
      // before or after the cmdlet name as that will cause
      // the command to fail.
      PowerShell ps = PowerShell.Create().AddCommand("Get-Process");

      // Create an IAsyncResult object and call the
      // BeginInvoke method to start running the
      // command pipeline asynchronously.
      IAsyncResult asyncpl = ps.BeginInvoke();

      // Using the PowerShell.Invoke method, run the command
      // pipeline using the default runspace.
      foreach (PSObject result in ps.EndInvoke(asyncpl))
      {
        Console.WriteLine("{0,-20}{1}",
                result.Members["ProcessName"].Value,
                result.Members["Id"].Value);
      } // End foreach.
      System.Console.WriteLine("Hit any key to exit.");
      System.Console.ReadKey();
    } // End Main.
  } // End HostPS3.
}

Zie ook

Een InitialSessionState maken

Een beperkte runspace maken