Snelstartgids voor Windows PowerShell-hosts

Artikel
09/24/2021
4 minuten om te lezen

Als u Windows PowerShell in uw toepassing wilt hosten, gebruikt u de klasse System.Management.Automation.PowerShell. Deze klasse biedt methoden voor het maken van een pijplijn met opdrachten en het uitvoeren van deze opdrachten in een runspace. De eenvoudigste manier om een hosttoepassing te maken, is door de standaardrunspace te gebruiken. De standaardrunspace bevat alle kerntaken Windows PowerShell opdrachten. Als u wilt dat uw toepassing slechts een subset van de Windows PowerShell 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 om opdrachten, parameters, instructies en scripts aan een pijplijn toe te voegen.

AddCommand

U gebruikt de methode System.Management.Automation.Powershell.AddCommand om opdrachten aan de pijplijn toe te voegen. Stel bijvoorbeeld dat u de lijst met lopende processen op de computer wilt op halen. U kunt deze opdracht als volgt uitvoeren.

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 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. Met de volgende code wordt bijvoorbeeld een lijst met alle processen met de naam die worden uitgevoerd PowerShell op de computer.

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

U kunt extra parameters toevoegen door de methode AddParameter 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 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 PowerShell worden uitgevoerd, 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("D:\PSScripts\MyScript.ps1").Invoke();

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

Een aangepaste runspace maken

Hoewel de standaardrunspace die in de vorige voorbeelden wordt gebruikt, alle kernopdrachten 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 prestatieverbetering) of om de mogelijkheid van de gebruiker om bewerkingen uit te voeren te beperken. Een runspace die slechts een beperkt aantal opdrachten beschikbaar maakt, wordt een beperkte runspace genoemd. Als u een beperkte runspace wilt maken, gebruikt u de klassen System.Management.Automation.Runspaces.Runspace en System.Management.Automation.Runspaces.InitialSessionState.

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

De runspace beperken

In het vorige voorbeeld hebben we een standaard System.Management.Automation.Runspaces.InitialSessionState-object gemaakt dat alle ingebouwde kernen Windows PowerShell. We hadden ook de methode System.Management.Automation.Runspaces.InitialSessionState.CreateDefault2 kunnen aangeroepen om een InitialSessionState-object te maken waarmee alleen de opdrachten in de Microsoft.PowerShell.Core-module worden geladen. Als u een beperktere 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.

Het gebruik van een runspace die alleen de opdrachten laadt die u opgeeft, biedt aanzienlijk betere prestaties.

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

Maak de initiële sessietoestand.

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 toon het resultaat.

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

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

Get-Command
Import-Module