Snabbstart för Windows PowerShell-värd

Artikel
09/24/2021
3 minuter för att läsa

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 runspace. Det enklaste sättet att skapa ett värdprogram är att använda standard-runspace. Standard-runspace innehåller alla grundläggande Windows PowerShell kommandon. Om du vill att programmet endast ska exponera en delmängd av Windows PowerShell måste du skapa ett anpassat körningsutrymme.

Använda standard-runspace

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.

Lägg tillKommando

Du använder metoden System.Management.Automation.Powershell.AddCommand 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 AddCommand mer än en gång innan du anropar metoden 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 metoden System.Management.Automation.PSCommand.AddParameter. 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 metoden AddParameter 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 metoden 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

Du kan simulera batchbearbetning med hjälp av metoden System.Management.Automation.PowerShell.AddStatement, 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 metoden System.Management.Automation.PowerShell.AddScript. 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 AddScript-metoden 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 runspace

Medan standard-runspace som används i föregående exempel läser in alla kärnkommandon Windows PowerShell kan du skapa ett anpassat runspace som bara läser in en angiven delmängd av alla kommandon. Du kanske vill göra detta för att förbättra prestanda (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 runspace 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 runspace

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 runspace som endast 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 initialt sessionstillstånd, som definierar och lägger till Get-Command Import-Module kommandona och i det inledande sessionstillståndet. Sedan skapar vi ett runspace som är begränsat av det inledande sessionstillståndet och kör kommandona i det körningsutrymmet.

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