Snabbstart för Windows PowerShell-värd

Artikel
01/26/2022

Om du Windows PowerShell värd för ditt program använder du klassen System.Management.Automation.PowerShell. Den här klassen innehåller metoder som skapar en pipeline med kommandon och sedan kör dessa kommandon i ett körningsutrymme. Det enklaste sättet att skapa ett värdprogram är att använda standardkörningsutrymmet. Standardkörningsutrymmet innehåller alla grundläggande Windows PowerShell kommandon. Om du vill att programmet endast ska exponera en delmängd av Windows PowerShell kommandon måste du skapa ett anpassat runspace.

Använda standardkörningsutrymmet

Till att börja med använder vi standard-runspace och använder metoderna i klassen System.Management.Automation.PowerShell för att lägga till kommandon, parametrar, instruktioner och skript i en pipeline.

AddCommand

Du använder System.Management.Automation.PowerShell. AddCommand -metoden för att lägga till kommandon i pipelinen. Anta till exempel att du vill hämta listan över processer som körs på datorn. Du kan köra det här kommandot på följande sätt.

Skapa ett System.Management.Automation.PowerShell-objekt.
```
PowerShell ps = PowerShell.Create();
```
Lägg till kommandot som du vill köra.
```
ps.AddCommand("Get-Process");
```
Anropa kommandot .
```
ps.Invoke();
```

Om du anropar metoden mer än en gång innan du anropar metoden AddCommand System.Management.Automation.PowerShell.Invoke, kommer resultatet av det första kommandot att ledas till det andra och så vidare. Om du inte vill skicka resultatet från ett tidigare kommando till ett kommando lägger du till det genom att anropa System.Management.Automation.PowerShell. AddStatement i stället.

AddParameter

I föregående exempel körs ett enda kommando utan några parametrar. Du kan lägga till parametrar i kommandot med hjälp av System.Management.Automation.PSCommand. AddParameter Metod. Följande kod hämtar till exempel en lista över alla processer med namnet som PowerShell körs på datorn.

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

Du kan lägga till ytterligare parametrar genom att anropa AddParameter metoden upprepade gånger.

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

Du kan också lägga till en ordlista med parameternamn och värden genom att anropa System.Management.Automation.PowerShell. AddParameter s-metoden.

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

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

AddStatement

Du kan simulera batchbearbetning med hjälp av System.Management.Automation.PowerShell. AddStatement -metoden, som lägger till ytterligare en -instruktion i slutet av pipelinen. Följande kod hämtar en lista över processer som körs med namnet PowerShell och hämtar sedan listan över tjänster som körs.

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

AddScript

Du kan köra ett befintligt skript genom att anropa System.Management.Automation.PowerShell. AddScript Metod. I följande exempel läggs ett skript till i pipelinen och körs. Det här exemplet förutsätter att det redan finns ett skript med MyScript.ps1 namnet i en mapp med namnet D:\PSScripts .

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

Det finns också en version av metoden AddScript som tar en boolesk parameter med namnet useLocalScope . Om den här parametern true är inställd på körs skriptet i det lokala omfånget. Följande kod kör skriptet i det lokala omfånget.

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

Skapa ett anpassat körningsutrymme

Medan standardkörningsutrymmet som används i föregående exempel läser in alla kärnkommandon Windows PowerShell, kan du skapa ett anpassat körningsutrymme som bara läser in en angiven delmängd av alla kommandon. Du kanske vill göra detta för att förbättra prestandan (inläsning av ett större antal kommandon är en prestandaträff) eller för att begränsa användarens möjlighet att utföra åtgärder. Ett körningsutrymme som bara exponerar ett begränsat antal kommandon kallas för ett begränsat körningsutrymme. Om du vill skapa ett begränsat körningsutrymme använder du klasserna System.Management.Automation.Runspaces.Runspace och System.Management.Automation.Runspaces.InitialSessionState.

Skapa ett InitialSessionState-objekt

Om du vill skapa ett anpassat runspace måste du först skapa ett System.Management.Automation.Runspaces.InitialSessionState-objekt. I följande exempel använder vi System.Management.Automation.Runspaces.RunspaceFactory för att skapa ett runspace när du har skapat ett InitialSessionState-standardobjekt.

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

Begränsa körningsutrymmet

I föregående exempel skapade vi ett standardobjekt för System.Management.Automation.Runspaces.InitialSessionState som läser in alla inbyggda Windows PowerShell. Vi kunde också ha anropat metoden System.Management.Automation.Runspaces.InitialSessionState.CreateDefault2 för att skapa ett InitialSessionState-objekt som endast skulle läsa in kommandona i Snapin-modulen Microsoft.PowerShell.Core. Om du vill skapa ett mer begränsat runspace måste du skapa ett tomt InitialSessionState-objekt genom att anropa metoden System.Management.Automation.Runspaces.InitialSessionState.Create och sedan lägga till kommandon i InitialSessionState.

Om du använder ett körningsutrymme som bara läser in de kommandon som du anger får du betydligt bättre prestanda.

Du använder metoderna i klassen System.Management.Automation.Runspaces.SessionStateCmdletEntry för att definiera cmdlets för det första sessionstillståndet. I följande exempel skapas ett tomt inledande sessionstillstånd och definierar och lägger sedan till Get-Command Import-Module kommandona och i det inledande sessionstillståndet. Sedan skapar vi ett körningsutrymme som är begränsat av det inledande sessionstillståndet och kör kommandona i det runspace.

Skapa det inledande sessionstillståndet.

InitialSessionState iss = InitialSessionState.Create();

Definiera och lägg till kommandon i det inledande sessionstillståndet.

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

Skapa och öppna runspace.

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

Kör ett kommando och visa resultatet.

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

När koden körs ser utdata ut så här.

Get-Command
Import-Module