Quickstart voor Windows PowerShell-host

Artikel
2025-03-25

Als u Windows PowerShell in uw toepassing wilt hosten, gebruikt u de klasse System.Management.Automation.PowerShell. Deze klasse biedt methoden waarmee u een pijplijn met opdrachten maakt en deze opdrachten vervolgens uitvoert in een runspace. De eenvoudigste manier om een hosttoepassing te maken, is door de standaardrunspace te gebruiken. De standaardrunspace bevat alle kernopdrachten van Windows PowerShell. Als u wilt dat uw toepassing slechts een subset van de Windows PowerShell-opdrachten beschikbaar maakt, moet u een aangepaste runspace maken.

De standaardrunspace gebruiken

Om te beginnen gebruiken we de standaardrunspace en gebruiken we de methoden van de klasse System.Management.Automation.PowerShell klasse om opdrachten, parameters, instructies en scripts toe te voegen aan een pijplijn.

AddCommand

U gebruikt de System.Management.Automation.PowerShell.AddCommand methode om opdrachten toe te voegen aan de pijplijn. Stel dat u de lijst met actieve processen op de computer wilt ophalen. De manier om deze opdracht uit te voeren is als volgt.

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 AddCommand meer dan één keer aanroept voordat u de methode System.Management.Automation.PowerShell.Invoke aanroept, wordt het resultaat van de eerste opdracht doorgesluisd naar de tweede, enzovoort. Als u het resultaat van een vorige opdracht niet wilt doorsluisen naar een opdracht, voegt u deze toe door de System.Management.Automation.PowerShell aan te roepen.AddStatement.

AddParameter

In het vorige voorbeeld wordt één opdracht uitgevoerd zonder parameters. U kunt parameters toevoegen aan de opdracht met behulp van de System.Management.Automation.PSCommand.AddParameter methode. Met de volgende code wordt bijvoorbeeld een lijst weergegeven met alle processen met de naam powershell uitgevoerd op de computer.

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

U kunt extra parameters toevoegen door de AddParameter methode herhaaldelijk aan te roepen.

PowerShell.Create().AddCommand("Get-ChildItem")
                   .AddParameter("Path", @"C:\Windows")
                   .AddParameter("Filter", "*.exe")
                   .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("Path", @"C:\Windows");
parameters.Add("Filter", "*.exe");

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

AddStatement

U kunt batchverwerking simuleren met behulp van de System.Management.Automation.PowerShell.AddStatement methode, waarmee een extra instructie wordt toegevoegd aan het einde van de pijplijn. De volgende code haalt een lijst met actieve processen op met de naam powershellen haalt vervolgens de lijst met actieve services op.

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 System.Management.Automation.PowerShell aan te roepen.AddScript methode. In het volgende voorbeeld wordt een script aan de pijplijn toegevoegd en uitgevoerd. In dit voorbeeld wordt ervan uitgegaan dat er al een script is met de naam MyScript.ps1 in een map met de naam D:\PSScripts.

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

Er is ook een versie van de methode AddScript die een booleaanse parameter met de naam useLocalScopegebruikt. 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(@"D:\PSScripts\MyScript.ps1", true).Invoke();

Een aangepaste runspace maken

Terwijl de standaardrunspace die in de vorige voorbeelden wordt gebruikt, alle kernopdrachten van Windows PowerShell laadt, kunt u een aangepaste runspace maken waarmee alleen een opgegeven subset van alle opdrachten wordt geladen. U kunt dit doen om de prestaties te verbeteren (het laden van een groter aantal opdrachten is een prestatietreffer) of om de mogelijkheid van de gebruiker om bewerkingen uit te voeren te beperken. Een runspace die slechts een beperkt aantal opdrachten weergeeft, wordt een beperkte runspace genoemd. Als u een beperkte runspace wilt maken, gebruikt u de System.Management.Automation.Runspaces.Runspace en System.Management.Automation.Runspaces.InitialSessionState klassen.

Een InitialSessionState-object maken

Als u een aangepaste runspace wilt maken, moet u eerst een System.Management.Automation.Runspaces.InitialSessionState-object maken. In het volgende voorbeeld gebruiken we de System.Management.Automation.Runspaces.RunspaceFactory om een runspace te maken na het maken van een standaard InitialSessionState-object.

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

De runspace beperken

In het vorige voorbeeld hebben we een standaardobject gemaakt System.Management.Automation.Runspaces.InitialSessionState object waarmee alle ingebouwde kerngeheugens van Windows PowerShell worden geladen. We kunnen ook de methode System.Management.Automation.Runspaces.InitialSessionState.CreateDefault2 hebben genoemd om een InitialSessionState-object te maken dat alleen de opdrachten in de Module Microsoft.PowerShell.Core laadt. Als u een meer beperkte runspace wilt maken, moet u een leeg InitialSessionState-object maken door de methode System.Management.Automation.Runspaces.InitialSessionState.Create aan te roepen en vervolgens opdrachten toe te voegen aan de InitialSessionState.

Als u een runspace gebruikt waarmee alleen de opdrachten die u opgeeft, worden de prestaties aanzienlijk verbeterd.

U gebruikt de methoden van de System.Management.Automation.Runspaces.SessionStateCmdletEntry klasse om cmdlets voor de eerste sessiestatus te definiëren. In het volgende voorbeeld wordt een lege initiële sessiestatus gemaakt, waarna de Get-Command en Import-Module opdrachten worden gedefinieerd en toegevoegd aan de initiële sessiestatus. Vervolgens maken we een runspace die is beperkt door die initiële sessiestatus en voeren we de opdrachten in die runspace uit.

Maak de initiële sessiestatus.

InitialSessionState iss = InitialSessionState.Create();

Opdrachten definiëren en toevoegen aan de status van de eerste sessie.

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

Maak en open de runspace.

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

Voer een opdracht uit en geef het resultaat weer.

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

Sluit de runspace.

rs.Close();

Wanneer deze code wordt uitgevoerd, ziet de uitvoer er als volgt uit.

Get-Command
Import-Module

Delen via