Snelstartgids voor Windows PowerShell-hosts

Artikel
01/26/2022

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 alleen een subset van de Windows PowerShell beschikbaar maakt, moet u een aangepaste runspace maken.

De standaardrunspace gebruiken

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

AddCommand

U gebruikt System.Management.Automation.PowerShell. AddCommand -methode om opdrachten toe te voegen aan de pijplijn. Stel bijvoorbeeld dat u de lijst met processen die worden uitgevoerd op de computer wilt zien. 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 meer dan één keer aanroept voordat u de methode AddCommand 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. weergeven.

AddParameter

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

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

U kunt extra parameters toevoegen door de methode herhaaldelijk AddParameter 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 System.Management.Automation.PowerShell aan te roepen. 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

U kunt batching simuleren met behulp van System.Management.Automation.PowerShell. AddStatement -methode, waarmee een extra instructie wordt toegevoegd aan het einde van de pijplijn. Met de volgende code wordt een lijst met lopende processen met de naam , en PowerShell vervolgens de lijst met services die 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 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 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 methode AddScript 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 kernwaarden 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 initialSessionState.

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

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, waarna de opdrachten en worden toegevoegd Get-Command Import-Module aan de initiële sessietoestand. 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();

Definieer opdrachten en voeg deze toe aan de initiële sessietoestand.

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 laat het resultaat zien.

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