Snabbstart för Windows PowerShell-värd

Artikel
2025-03-25

Som värd för Windows PowerShell i 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örningen. Standardkörningen innehåller alla Windows PowerShell-kärnkommandon. Om du bara vill att programmet ska exponera en delmängd av Windows PowerShell-kommandona måste du skapa en anpassad runspace.

Använda standardkörningsutrymmet

Till att börja med använder vi standardkörningen 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 metod 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. Sättet att köra det här kommandot är på följande sätt.

Skapa ett System.Management.Automation.PowerShell-objekt.
```
PowerShell ps = PowerShell.Create();
```
Lägg till det kommando 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 skickas resultatet från det första kommandot till det andra och så vidare. Om du inte vill skicka resultatet av 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 som heter powershell som 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 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 powershelloch 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 namnet MyScript.ps1 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 är inställd på truekö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 standardkörningen som användes i föregående exempel läser in alla windows PowerShell-kärnkommandon kan du skapa en anpassad 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 prestandan (att läsa in ett större antal kommandon är en prestandaträff) eller för att begränsa användarens förmåga att utföra åtgärder. Ett körningsutrymme som endast 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 System.Management.Automation.Runspaces.Runspaces.Runspace och System.Management.Automation.Runspaces.InitialSessionState klasser.

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 en 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();
rs.Close();

Begränsa körningsytan

I föregående exempel skapade vi ett standardobjekt System.Management.Automation.Runspaces.InitialSessionState objekt som läser in alla inbyggda Windows PowerShell-kärnor. Vi kunde också ha anropat metoden System.Management.Automation.Runspaces.InitialSessionState.CreateDefault2 för att skapa ett InitialSessionState-objekt som bara 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 avsevärt bättre prestanda.

Du använder metoderna i klassen System.Management.Automation.Runspaces.SessionStateCmdletEntry för att definiera cmdletar för det inledande sessionstillståndet. I följande exempel skapas ett tomt inledande sessionstillstånd, och sedan definieras och läggs kommandona Get-Command och Import-Module till det inledande sessionstillståndet. Sedan skapar vi ett körningsutrymme som begränsas 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 körningsytan.

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

Stäng körningsytan.

rs.Close();

När du kör ser utdata för den här koden ut så här.

Get-Command
Import-Module

Dela via