Início Rápido do Host do Windows PowerShell

Para hospedar o Windows PowerShell em seu aplicativo, use a classe System.Management.Automation.PowerShell. Essa classe fornece métodos que criam um pipeline de comandos e, em seguida, executam esses comandos em um runspace. A maneira mais simples de criar um aplicativo host é usar o runspace padrão. O runspace padrão contém todos os comandos principais do Windows PowerShell. Se você quiser que seu aplicativo exponha apenas um subconjunto dos comandos do Windows PowerShell, crie um runspace personalizado.

Usando o runspace padrão

Para começar, usaremos o runspace padrão e usaremos os métodos da classe System.Management.Automation.PowerShell para adicionar comandos, parâmetros, instruções e scripts a um pipeline.

AddCommand

Use o System.Management.Automation.PowerShell.AddCommand método para adicionar comandos ao pipeline. Por exemplo, suponha que você queira obter a lista de processos em execução no computador. A maneira de executar esse comando é a seguinte.

1. Crie um objeto System.Management.Automation.PowerShell.

   PowerShell ps = PowerShell.Create();
   

2. Adicione o comando que você deseja executar.

   ps.AddCommand("Get-Process");
   

3. Invoque o comando.

   ps.Invoke();
   

Se você chamar o método AddCommand mais de uma vez antes de chamar o método System.Management.Automation.PowerShell.Invoke, o resultado do primeiro comando será canalizado para o segundo e assim por diante. Se você não quiser canalizar o resultado de um comando anterior para um comando, adicione-o chamando o System.Management.Automation.PowerShell.AddStatement em vez disso.

AddParameter

O exemplo anterior executa um único comando sem parâmetros. Você pode adicionar parâmetros ao comando usando o System.Management.Automation.PSCommand. métodoAddParameter. Por exemplo, o código a seguir obtém uma lista de todos os processos nomeados powershell em execução no computador.

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

Você pode adicionar parâmetros adicionais chamando o método AddParameter repetidamente.

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

Você também pode adicionar um dicionário de nomes e valores de parâmetro chamando o método System.Management.Automation.PowerShell.AddParameters método.

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

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

AddStatement

Você pode simular o envio em lote usando o System.Management.Automation.PowerShell.AddStatement método, que adiciona uma instrução adicional ao final do pipeline. O código a seguir obtém uma lista de processos em execução com o nome powershelle, em seguida, obtém a lista de serviços em execução.

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

AddScript

Você pode executar um script existente chamando o System.Management.Automation.PowerShell. métodoAddScript. O exemplo a seguir adiciona um script ao pipeline e o executa. Este exemplo pressupõe que já exista um script chamado MyScript.ps1 em uma pasta chamada D:\PSScripts.

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

Há também uma versão do método AddScript que usa um parâmetro booliano chamado useLocalScope. Se esse parâmetro for definido como true, o script será executado no escopo local. O código a seguir executará o script no escopo local.

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

Criando um runspace personalizado

Embora o runspace padrão usado nos exemplos anteriores carregue todos os comandos principais do Windows PowerShell, você pode criar um runspace personalizado que carrega apenas um subconjunto especificado de todos os comandos. Talvez você queira fazer isso para melhorar o desempenho (carregar um número maior de comandos é um sucesso de desempenho) ou restringir a capacidade do usuário de executar operações. Um runspace que expõe apenas um número limitado de comandos é chamado de runspace restrito. Para criar um runspace restrito, use as classes System.Management.Automation.Runspaces.Runspace e System.Management.Automation.Runspaces.InitialSessionState.

Criando um objeto InitialSessionState

Para criar um runspace personalizado, primeiro você deve criar um objeto System.Management.Automation.Runspaces.InitialSessionState. No exemplo a seguir, usamos o System.Management.Automation.Runspaces.RunspaceFactory para criar um runspace depois de criar um objeto InitialSessionState padrão.

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

Restringir o runspace

No exemplo anterior, criamos um objeto padrão System.Management.Automation.Runspaces.InitialSessionState que carrega todo o Windows PowerShell principal interno. Também poderíamos ter chamado o método System.Management.Automation.Runspaces.InitialSessionState.CreateDefault2 para criar um objeto InitialSessionState que carregaria apenas os comandos no snapin Microsoft.PowerShell.Core. Para criar um runspace mais restrito, você deve criar um objeto InitialSessionState vazio chamando o método System.Management.Automation.Runspaces.InitialSessionState.Create e, em seguida, adicionar comandos ao InitialSessionState.

O uso de um runspace que carrega apenas os comandos especificados fornece um desempenho significativamente aprimorado.

Use os métodos da classe System.Management.Automation.Runspaces.SessionStateCmdletEntry para definir cmdlets para o estado inicial da sessão. O exemplo a seguir cria um estado de sessão inicial vazio e, em seguida, define e adiciona os comandos Get-Command e Import-Module ao estado inicial da sessão. Em seguida, criamos um runspace restrito por esse estado de sessão inicial e executamos os comandos nesse runspace.

Crie o estado inicial da sessão.

InitialSessionState iss = InitialSessionState.Create();

Defina e adicione comandos ao estado inicial da sessão.

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

Crie e abra o runspace.

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

Execute um comando e mostre o resultado.

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

Feche o runspace.

rs.Close();

Quando executada, a saída desse código será exibida da seguinte maneira.

Get-Command
Import-Module