Guida introduttiva dell'host di Windows PowerShell

Articolo
01/26/2022

Per ospitare Windows PowerShell nell'applicazione, usare la classe System.Management.Automation.PowerShell. Questa classe fornisce metodi che creano una pipeline di comandi e quindi eseguono tali comandi in uno spazio di esecuzione. Il modo più semplice per creare un'applicazione host è usare lo spazio di esecuzione predefinito. Lo spazio di esecuzione predefinito contiene tutti i comandi Windows PowerShell core. Se si vuole che l'applicazione esponga solo un subset dei comandi Windows PowerShell, è necessario creare uno spazio di esecuzione personalizzato.

Uso dello spazio di esecuzione predefinito

Per iniziare, si userà lo spazio di esecuzione predefinito e si useranno i metodi della classe System.Management.Automation.PowerShell per aggiungere comandi, parametri, istruzioni e script a una pipeline.

AddCommand

Usare System.Management.Automation.PowerShell. AddCommand per aggiungere comandi alla pipeline. Si supponga, ad esempio, di voler ottenere l'elenco dei processi in esecuzione nel computer. Il modo per eseguire questo comando è il seguente.

Creare un oggetto System.Management.Automation.PowerShell.
```
PowerShell ps = PowerShell.Create();
```
Aggiungere il comando che si vuole eseguire.
```
ps.AddCommand("Get-Process");
```
Richiamare il comando .
```
ps.Invoke();
```

Se si chiama il metodo più volte prima di chiamare il metodo AddCommand System.Management.Automation.PowerShell.Invoke, il risultato del primo comando viene reindirizzato al secondo e così via. Se non si vuole pipere il risultato di un comando precedente a un comando, aggiungerlo chiamando System.Management.Automation.PowerShell. AddStatement .

AddParameter

L'esempio precedente esegue un singolo comando senza parametri. È possibile aggiungere parametri al comando usando System.Management.Automation.PSCommand. AddParameter ProcessOnStatus. Ad esempio, il codice seguente ottiene un elenco di tutti i processi denominati PowerShell in esecuzione nel computer.

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

È possibile aggiungere altri parametri chiamando ripetutamente AddParameter il metodo .

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

È anche possibile aggiungere un dizionario di nomi e valori di parametri chiamando System.Management.Automation.PowerShell. AddParameter Metodo s.

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

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

AddStatement

È possibile simulare l'invio in batch usando System.Management.Automation.PowerShell. AddStatement metodo , che aggiunge un'istruzione aggiuntiva alla fine della pipeline. Il codice seguente ottiene un elenco di processi in esecuzione con il nome PowerShell , quindi ottiene l'elenco dei servizi in esecuzione.

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

AddScript

È possibile eseguire uno script esistente chiamando System.Management.Automation.PowerShell. AddScript ProcessOnStatus. L'esempio seguente aggiunge uno script alla pipeline e lo esegue. In questo esempio si presuppone che sia già presente uno script MyScript.ps1 denominato in una cartella denominata D:\PSScripts .

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

Esiste anche una versione del metodo AddScript che accetta un parametro booleano denominato useLocalScope . Se questo parametro è impostato su true , lo script viene eseguito nell'ambito locale. Il codice seguente eseguirà lo script nell'ambito locale.

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

Creazione di uno spazio di esecuzione personalizzato

Mentre lo spazio di esecuzione predefinito usato negli esempi precedenti carica tutti i comandi Windows PowerShell di base, è possibile creare uno spazio di esecuzione personalizzato che carica solo un subset specificato di tutti i comandi. È possibile eseguire questa operazione per migliorare le prestazioni (il caricamento di un numero maggiore di comandi è un miglioramento delle prestazioni) o per limitare la capacità dell'utente di eseguire operazioni. Uno spazio di esecuzione che espone solo un numero limitato di comandi è detto spazio di esecuzione vincolato. Per creare uno spazio di esecuzione vincolato, usare le classi System.Management.Automation.Runspaces.Runspace e System.Management.Automation.Runspaces.InitialSessionState.

Creazione di un oggetto InitialSessionState

Per creare uno spazio di esecuzione personalizzato, è innanzitutto necessario creare un oggetto System.Management.Automation.Runspaces.InitialSessionState. Nell'esempio seguente viene utilizzato System.Management.Automation.Runspaces.RunspaceFactory per creare uno spazio di esecuzione dopo aver creato un oggetto InitialSessionState predefinito.

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

Vincolare lo spazio di esecuzione

Nell'esempio precedente è stato creato un oggetto System.Management.Automation.Runspaces.InitialSessionState predefinito che carica tutti i core Windows PowerShell. Sarebbe stato anche possibile chiamare il metodo System.Management.Automation.Runspaces.InitialSessionState.CreateDefault2 per creare un oggetto InitialSessionState che caricasse solo i comandi nello snapin Microsoft.PowerShell.Core. Per creare uno spazio di esecuzione più vincolato, è necessario creare un oggetto InitialSessionState vuoto chiamando il metodo System.Management.Automation.Runspaces.InitialSessionState.Create e quindi aggiungere comandi a InitialSessionState.

L'uso di uno spazio di esecuzione che carica solo i comandi specificati offre prestazioni notevolmente migliorate.

Usare i metodi della classe System.Management.Automation.Runspaces.SessionStateCmdletEntry per definire i cmdlet per lo stato della sessione iniziale. Nell'esempio seguente viene creato uno stato sessione iniziale vuoto, quindi vengono definiti e aggiunti i Get-Command comandi e allo stato della sessione Import-Module iniziale. Viene quindi creato uno spazio di esecuzione vincolato dallo stato iniziale della sessione e vengono eseguiti i comandi in tale spazio di esecuzione.

Creare lo stato iniziale della sessione.

InitialSessionState iss = InitialSessionState.Create();

Definire e aggiungere comandi allo stato della sessione iniziale.

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);

Creare e aprire lo spazio di esecuzione.

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

Eseguire un comando e visualizzare il risultato.

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);
}

Quando viene eseguito, l'output di questo codice sarà simile al seguente.

Get-Command
Import-Module