Démarrage rapide de l’hôte Windows PowerShell

2025-03-25

Pour héberger Windows PowerShell dans votre application, vous utilisez la classe System.Management.Automation.PowerShell. Cette classe fournit des méthodes qui créent un pipeline de commandes, puis exécutent ces commandes dans un runspace. La façon la plus simple de créer une application hôte consiste à utiliser l’espace d’exécution par défaut. L’espace d’exécution par défaut contient toutes les commandes Windows PowerShell principales. Si vous souhaitez que votre application expose uniquement un sous-ensemble des commandes Windows PowerShell, vous devez créer un runspace personnalisé.

Utilisation de l’instance d’exécution par défaut

Pour commencer, nous allons utiliser l’espace d’exécution par défaut et utiliser les méthodes de l'System.Management.Automation.PowerShell classe pour ajouter des commandes, des paramètres, des instructions et des scripts à un pipeline.

AddCommand

Vous utilisez la System.Management.Automation.PowerShell.AddCommand méthode pour ajouter des commandes au pipeline. Par exemple, supposons que vous souhaitiez obtenir la liste des processus en cours d’exécution sur l’ordinateur. La façon d’exécuter cette commande est la suivante.

Créez un objet System.Management.Automation.PowerShell.
```
PowerShell ps = PowerShell.Create();
```
Ajoutez la commande que vous souhaitez exécuter.
```
ps.AddCommand("Get-Process");
```
Appelez la commande.
```
ps.Invoke();
```

Si vous appelez la méthode AddCommand plusieurs fois avant d’appeler la méthode System.Management.Automation.PowerShell.Invoke, le résultat de la première commande est redirigé vers la seconde, etc. Si vous ne souhaitez pas diriger le résultat d’une commande précédente vers une commande, ajoutez-la en appelant la System.Management.Automation.PowerShell.AddStatement à la place.

AddParameter

L’exemple précédent exécute une seule commande sans aucun paramètre. Vous pouvez ajouter des paramètres à la commande à l’aide de l'System.Management.Automation.PSCommand. méthodeAddParameter. Par exemple, le code suivant obtient la liste de tous les processus nommés powershell en cours d’exécution sur l’ordinateur.

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

Vous pouvez ajouter des paramètres supplémentaires en appelant la méthode AddParameter à plusieurs reprises.

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

Vous pouvez également ajouter un dictionnaire de noms et de valeurs de paramètres en appelant la méthode 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

Vous pouvez simuler le traitement par lots à l’aide de la System.Management.Automation.PowerShell.AddStatement méthode, qui ajoute une instruction supplémentaire à la fin du pipeline. Le code suivant obtient une liste de processus en cours d’exécution avec le nom powershell, puis obtient la liste des services en cours d’exécution.

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

AddScript

Vous pouvez exécuter un script existant en appelant la System.Management.Automation.PowerShell. méthodeAddScript. L’exemple suivant ajoute un script au pipeline et l’exécute. Cet exemple suppose qu’il existe déjà un script nommé MyScript.ps1 dans un dossier nommé D:\PSScripts.

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

Il existe également une version de la méthode AddScript qui accepte un paramètre booléen nommé useLocalScope. Si ce paramètre est défini sur true, le script est exécuté dans l’étendue locale. Le code suivant exécute le script dans l’étendue locale.

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

Création d’un runspace personnalisé

Bien que l’espace d’exécution par défaut utilisé dans les exemples précédents charge toutes les commandes Windows PowerShell principales, vous pouvez créer un runspace personnalisé qui charge uniquement un sous-ensemble spécifié de toutes les commandes. Vous pouvez le faire pour améliorer les performances (le chargement d’un plus grand nombre de commandes est un succès de performances) ou pour restreindre la capacité de l’utilisateur à effectuer des opérations. Un runspace qui expose uniquement un nombre limité de commandes est appelé un runspace limité. Pour créer un runspace contraint, vous utilisez les classes System.Management.Automation.Runspaces.Runspaces et System.Management.Automation.Runspaces.InitialSessionState.

Création d’un objet InitialSessionState

Pour créer un runspace personnalisé, vous devez d’abord créer un objet System.Management.Automation.Runspaces.InitialSessionState. Dans l’exemple suivant, nous utilisons l'System.Management.Automation.Runspaces.RunspaceFactory pour créer un runspace après avoir créé un objet InitialSessionState par défaut.

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

Limitation de l’espace d’exécution

Dans l’exemple précédent, nous avons créé un objet par défaut System.Management.Automation.Runspaces.InitialSessionState qui charge tous les composants Windows PowerShell intégrés. Nous pourrions également appeler la méthode System.Management.Automation.Runspaces.InitialSessionState.CreateDefault2 pour créer un objet InitialSessionState qui charge uniquement les commandes dans le composant logiciel enfichable Microsoft.PowerShell.Core. Pour créer un runspace plus limité, vous devez créer un objet InitialSessionState vide en appelant la méthode system.Management.Automation.Runspaces.InitialSessionState.Create, puis ajouter des commandes à InitialSessionState.

L’utilisation d’un runspace qui charge uniquement les commandes que vous spécifiez offre des performances considérablement améliorées.

Vous utilisez les méthodes de la classe System.Management.Automation.Runspaces.SessionStateCmdletEntry pour définir des applets de commande pour l’état de session initial. L’exemple suivant crée un état de session initial vide, puis définit et ajoute les commandes Get-Command et Import-Module à l’état de session initial. Nous créons ensuite un runspace limité par cet état de session initial et exécutons les commandes dans cet espace d’exécution.

Créez l’état de session initial.

InitialSessionState iss = InitialSessionState.Create();

Définissez et ajoutez des commandes à l’état de session initial.

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

Créez et ouvrez l’espace d’exécution.

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

Exécutez une commande et affichez le résultat.

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

Fermez l’espace d’exécution.

rs.Close();

Lors de l’exécution, la sortie de ce code se présente comme suit.

Get-Command
Import-Module