Guida introduttiva all'host di Windows PowerShell

Articolo
2025-03-25

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 consiste nell'usare lo spazio di esecuzione predefinito. Lo spazio di esecuzione predefinito contiene tutti i comandi principali di Windows PowerShell. Se si vuole che l'applicazione esponga solo un subset dei comandi di 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 il System.Management.Automation.PowerShell.AddCommand metodo 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 da eseguire.
```
ps.AddCommand("Get-Process");
```
Richiamare il comando.
```
ps.Invoke();
```

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

AddParameter

Nell'esempio precedente viene eseguito un singolo comando senza parametri. È possibile aggiungere parametri al comando usando il System.Management.Automation.PSCommand.AddParameter metodo. 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 il metodo AddParameter.

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 il metodo System.Management.Automation.PowerShell.AddParameters.

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 il 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 powershelle 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 il System.Management.Automation.PowerShell.AddScript metodo. Nell'esempio seguente viene aggiunto uno script alla pipeline ed eseguito. In questo esempio si presuppone che esista già uno script denominato MyScript.ps1 in una cartella denominata D:\PSScripts.

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

È disponibile 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 principali di Windows PowerShell, è 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 successo delle prestazioni) o per limitare la capacità dell'utente di eseguire operazioni. Uno spazio di esecuzione che espone solo un numero limitato di comandi è denominato spazio di esecuzione vincolato. Per creare uno spazio di esecuzione vincolato, usare le classi System.Management.Automation.Run spaces.Runspaces.Runspace e System.Management.Automation.Runspaces.InitialSessionState.

Creazione di un oggetto InitialSessionState

Per creare uno spazio di esecuzione personalizzato, è prima necessario creare un oggetto System.Management.Automation.Runspaces.InitialSessionState. Nell'esempio seguente viene usato il 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();
rs.Close();

Vincolare lo spazio di esecuzione

Nell'esempio precedente è stato creato un oggetto predefinito System.Management.Automation.Runspaces.InitialSessionState che carica tutti i componenti di base predefiniti di Windows PowerShell. È anche possibile chiamare il metodo System.Management.Automation.Runspaces.InitialSessionState.CreateDefault2 per creare un oggetto InitialSessionState che caricherebbe 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 iniziale della sessione. L'esempio seguente crea uno stato di sessione iniziale vuoto, quindi definisce e aggiunge i comandi Get-Command e Import-Module allo stato iniziale della sessione. Viene quindi creato uno spazio di esecuzione vincolato da tale stato iniziale della sessione ed è possibile eseguire i comandi in tale spazio di esecuzione.

Creare lo stato iniziale della sessione.

InitialSessionState iss = InitialSessionState.Create();

Definire e aggiungere comandi allo stato iniziale della sessione.

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

Chiudere lo spazio di esecuzione.

rs.Close();

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

Get-Command
Import-Module

Condividi tramite