Windows PowerShell-Host: Schnellstart

Um Windows PowerShell in Ihrer Anwendung zu hosten, verwenden Sie die System.Management.Automation.PowerShell-Klasse. Diese Klasse stellt Methoden bereit, die eine Pipeline von Befehlen erstellen und diese Befehle dann in einem Runspace ausführen. Die einfachste Möglichkeit zum Erstellen einer Hostanwendung ist die Verwendung des Standard-Runspace. Der Standard-Runspace enthält alle Kernbefehle Windows PowerShell. Wenn Ihre Anwendung nur eine Teilmenge der Windows PowerShell Befehle verfügbar machen soll, müssen Sie einen benutzerdefinierten Runspace erstellen.

Verwenden des Standard-Runspaces

Zunächst verwenden wir den Standard-Runspace und die Methoden der System.Management.Automation.PowerShell-Klasse, um einer Pipeline Befehle, Parameter, Anweisungen und Skripts hinzuzufügen.

AddCommand

Sie verwenden System.Management.Automation.PowerShell. AddCommand -Methode zum Hinzufügen von Befehlen zur Pipeline. Angenommen, Sie möchten die Liste der ausgeführten Prozesse auf dem Computer abrufen. Führen Sie diesen Befehl wie folgt aus.

1. Erstellen Sie ein System.Management.Automation.PowerShell-Objekt.

   PowerShell ps = PowerShell.Create();
   

2. Fügen Sie den Befehl hinzu, den Sie ausführen möchten.

   ps.AddCommand("Get-Process");
   

3. Rufen Sie den Befehl auf.

   ps.Invoke();
   

Wenn Sie die AddCommand Methode mehr als einmal aufrufen, bevor Sie die System.Management.Automation.PowerShell.Invoke-Methode aufrufen, wird das Ergebnis des ersten Befehls an den zweiten befehl weitergeleitt usw. Wenn Sie das Ergebnis eines vorherigen Befehls nicht an einen Befehl weiterleiten möchten, fügen Sie es durch Aufrufen von System.Management.Automation.PowerShell hinzu. AddStatement instead. (Anforderungsobjekt konnte nicht analysiert werden: Erwartet wurde, dass ‚key‘ und ‚value‘ für base_parameters des JSON-Zuordnungsfelds festgelegt werden. Stattdessen wurde ‚key: „...“‘ festgelegt.)

AddParameter

Im vorherigen Beispiel wird ein einzelner Befehl ohne Parameter ausgeführt. Sie können dem Befehl Parameter hinzufügen, indem Sie System.Management.Automation.PSCommand verwenden. AddParameter -Methode. Der folgende Code ruft beispielsweise eine Liste aller Prozesse ab, die PowerShell auf dem Computer ausgeführt werden.

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

Sie können zusätzliche Parameter hinzufügen, indem Sie die AddParameter -Methode wiederholt aufrufen.

PowerShell.Create().AddCommand("Get-ChildItem")
                   .AddParameter("Path", @"c:\Windows")
                   .AddParameter("Filter", "*.exe")
                   .Invoke();

Sie können auch ein Wörterbuch mit Parameternamen und -werten hinzufügen, indem Sie System.Management.Automation.PowerShell aufrufen. AddParameter s-Methode.

IDictionary parameters = new Dictionary<String, String>();
parameters.Add("Path", @"c:\Windows");
parameters.Add("Filter", "*.exe");

PowerShell.Create().AddCommand("Get-Process")
   .AddParameters(parameters)
      .Invoke()

AddStatement

Sie können die Batchverarbeitung mithilfe von System.Management.Automation.PowerShell simulieren. AddStatement -Methode, die am Ende der Pipeline eine zusätzliche -Anweisung hinzufügt. Der folgende Code ruft eine Liste der ausgeführten Prozesse mit dem Namen PowerShell ab und ruft dann die Liste der ausgeführten Dienste ab.

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

AddScript

Sie können ein vorhandenes Skript ausführen, indem Sie System.Management.Automation.PowerShell aufrufen. AddScript -Methode. Im folgenden Beispiel wird der Pipeline ein Skript hinzugefügt und ausgeführt. In diesem Beispiel wird davon ausgegangen, dass in einem Ordner mit dem Namen bereits ein Skript namens vorhanden MyScript.ps1 D:\PSScripts ist.

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

Es gibt auch eine Version der AddScript -Methode, die einen booleschen Parameter mit dem Namen useLocalScope annimmt. Wenn dieser Parameter auf festgelegt true ist, wird das Skript im lokalen Bereich ausgeführt. Mit dem folgenden Code wird das Skript im lokalen Bereich ausgeführt.

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

Erstellen eines benutzerdefinierten Runspaces

Während der in den vorherigen Beispielen verwendete Standard-Runspace alle Windows PowerShell Befehle lädt, können Sie einen benutzerdefinierten Runspace erstellen, der nur eine angegebene Teilmenge aller Befehle lädt. Sie können dies tun, um die Leistung zu verbessern (das Laden einer größeren Anzahl von Befehlen ist ein Leistungstreffer), oder um die Fähigkeit des Benutzers zum Ausführen von Vorgängen einzuschränken. Ein Runspace, der nur eine begrenzte Anzahl von Befehlen verfügbar macht, wird als eingeschränkter Runspace bezeichnet. Um einen eingeschränkten Runspace zu erstellen, verwenden Sie die Klassen System.Management.Automation.Runspaces.Runspace und System.Management.Automation.Runspaces.InitialSessionState.

Erstellen eines InitialSessionState-Objekts

Um einen benutzerdefinierten Runspace zu erstellen, müssen Sie zunächst ein System.Management.Automation.Runspaces.InitialSessionState-Objekt erstellen. Im folgenden Beispiel verwenden wir System.Management.Automation.Runspaces.RunspaceFactory, um nach dem Erstellen eines InitialSessionState-Standardobjekts einen Runspace zu erstellen.

InitialSessionState iss = InitialSessionState.CreateDefault();
Runspace rs = RunspaceFactory.CreateRunspace(iss);
rs.Open();
PowerShell ps = PowerShell.Create();
ps.Runspace = rs;
ps.AddCommand("Get-Command");
ps.Invoke();

Einschränken des Runspaces

Im vorherigen Beispiel haben wir ein Standardmäßiges System.Management.Automation.Runspaces.InitialSessionState-Objekt erstellt, das alle integrierten Core-Windows PowerShell lädt. Wir hätten auch die Methode System.Management.Automation.Runspaces.InitialSessionState.CreateDefault2 verwenden können, um ein InitialSessionState-Objekt zu erstellen, das nur die Befehle im Microsoft.PowerShell.Core-Snapin laden würde. Um einen stärker eingeschränkten Runspace zu erstellen, müssen Sie ein leeres InitialSessionState-Objekt erstellen, indem Sie die Methode System.Management.Automation.Runspaces.InitialSessionState.Create aufrufen und dann InitialSessionState Befehle hinzufügen.

Die Verwendung eines Runspace, der nur die von Ihnen angegebenen Befehle lädt, bietet eine deutlich verbesserte Leistung.

Sie verwenden die Methoden der System.Management.Automation.Runspaces.SessionStateCmdletEntry-Klasse, um Cmdlets für den anfänglichen Sitzungszustand zu definieren. Im folgenden Beispiel wird ein leerer anfänglicher Sitzungszustand erstellt. Anschließend werden die Befehle und definiert und Get-Command Import-Module dem anfänglichen Sitzungszustand hinzugefügt. Anschließend erstellen wir einen Runspace, der durch diesen anfänglichen Sitzungszustand eingeschränkt ist, und führen die Befehle in diesem Runspace aus.

Erstellen Sie den anfänglichen Sitzungszustand.

InitialSessionState iss = InitialSessionState.Create();

Definieren Sie befehle, und fügen Sie sie dem anfänglichen Sitzungszustand hinzu.

SessionStateCmdletEntry getCommand = new SessionStateCmdletEntry(
    "Get-Command", typeof(Microsoft.PowerShell.Commands.GetCommandCommand), "");
SessionStateCmdletEntry importModule = new SessionStateCmdletEntry(
    "Import-Module", typeof(Microsoft.PowerShell.Commands.ImportModuleCommand), "");
iss.Commands.Add(getCommand);
iss.Commands.Add(importModule);

Erstellen und öffnen Sie den Runspace.

Runspace rs = RunspaceFactory.CreateRunspace(iss);
rs.Open();

Führen Sie einen Befehl aus, und zeigen Sie das Ergebnis an.

PowerShell ps = PowerShell.Create();
ps.Runspace = rs;
ps.AddCommand("Get-Command");
Collection<CommandInfo> result = ps.Invoke<CommandInfo>();
foreach (var entry in result)
{
    Console.WriteLine(entry.Name);
}

Bei der Ausführung sieht die Ausgabe dieses Codes wie folgt aus.

Get-Command
Import-Module