Créer des interfaces graphiques PowerShell WPF : Fonctions, entrées et résultats

Tutoriels
PowerShell

PowerShell est un outil en ligne de commande, mais saviez-vous qu’il peut également être utilisé comme base pour des interfaces graphiques ? Parfois, l’interface en ligne de commande n’est pas la meilleure option pour une instance particulière. La création d’une interface graphique PowerShell pour votre service d’assistance est un excellent exemple. C’est l’un de ces moments où il est plus approprié de créer des outils graphiques.

Not a reader? Watch this related video.

Appliquez une vérification de l’utilisateur final lors de la réinitialisation des mots de passe au service d’assistance. Réduisez votre vulnérabilité à l’ingénierie sociale avec Specops Secure Service Desk. Contactez-nous pour une démonstration !

PowerShell peut utiliser et exposer les fonctionnalités et les caractéristiques de .NET. Par conséquent, il est possible de créer des interfaces graphiques pour les scripts que vous créez. La création d’interfaces graphiques PowerShell peut sembler compliquée, surtout si vous êtes débutant.

Mais si vous avez une expérience de base avec les scripts PowerShell, il n’y a aucune raison pour que vous n’appreniez pas et n’adaptiez pas la pratique de la création d’interfaces graphiques pour vos scripts.

Dans cet article, vous apprendrez comment créer une interface graphique PowerShell en utilisant le Windows Presentation Framework (WPF).

Prérequis

Avant de vous plonger dans le sujet, assurez-vous de répondre aux exigences suivantes :

  1. Visual Studio 2017 ou une version ultérieure – Vous l’utiliserez pour créer l’interface utilisateur graphique à l’aide de WPF. Vous pouvez télécharger une version gratuite ou communautaire.
  2. A script editor – I use Visual Studio Code, but you can also use another text editor of your choice. Some other options are Notepad++ and the built-in PowerShell ISE
  3. A Windows 10 computer with Windows PowerShell 5.1.

Construction du script

Dans cet article, vous allez créer un script simple nommé Main.ps1.Dans le script, vous allez écrire du code qui extraira des informations sur le disque à partir d’un système local ou distant en interrogeant la classe WMI Win32_LogicalDisk.

Vous aurez besoin d’un script pour envelopper une interface graphique en premier. J’ai choisi d’utiliser un script qui vous permet de fournir un nom d’ordinateur et de consulter les informations sur le disque. Cependant, cela n’est en aucun cas nécessaire pour construire une interface graphique. Utilisez les techniques que vous apprenez dans cet article pour adapter vos interfaces graphiques à vos propres scripts.

À titre d’exemple de script, je vais créer une fonction qui effectue les actions suivantes:

  1. Accepter une entrée pour le nom de l’ordinateur à interroger
  2. Interroger l’ordinateur et stocker les informations sur les disques fixes dans une variable
  3. Retourner les résultats

Écriture de la fonction

Voici la fonction que vous utiliserez pour ce projet, appelée Get-FixedDisk. Le but de ce projet est d’obtenir les informations sur les disques non amovibles ou fixes de la machine cible.

Ce morceau de code peut être utilisé tel quel, mais la création d’une interface graphique serait bénéfique si vous voulez simplement effectuer une requête rapide sans avoir à charger la fonction et à taper manuellement les commandes à chaque fois.

Function Get-FixedDisk {
    [CmdletBinding()]
    # Ce bloc param() indique le début de la déclaration des paramètres
    param (
        <# 
            Ce paramètre accepte le nom de l'ordinateur cible.
            Il est également défini comme obligatoire afin que la fonction ne s'exécute pas sans spécifier la valeur.
        #>
        [Parameter(Mandatory)]
        [string]$Computer
    )
    <#
        Commande de requête WMI qui obtient la liste de tous les disques logiques et enregistre les résultats dans une variable nommée $DiskInfo
    #>
    $DiskInfo = Get-WmiObject Win32_LogicalDisk -ComputerName $Computer -Filter 'DriveType=3'
   $DiskInfo
}

Vous pouvez voir que j’ai ajouté un bloc param() dans le code. Cela sert à indiquer à la fonction d’accepter des entrées en fonction du type de données indiqué.

Dans l’exemple, j’ai ajouté un paramètre Computer qui accepte une valeur de chaîne. De plus, en ajoutant l’attribut de paramètre Mandatory, cela garantit que la fonction ne s’exécute pas si le paramètre Computer n’est pas spécifié lors de l’exécution.

Ensuite, la ligne 18 montre la commande de requête WMI réelle qui obtient la liste de tous les disques logiques et enregistre les résultats dans une variable nommée $DiskInfo. J’ai également ajouté un filtre pour n’obtenir que les disques avec DriveType=3. Ce filtre garantit que seules les informations sur les disques locaux fixes sont affichées.

Importer le code (Dot Sourcing)

À ce stade, vous disposez maintenant d’un script fonctionnel et êtes prêt à le tester. Mais avant de pouvoir tester le script, vous devez importer le code dans une session PowerShell. Une façon de charger du code dans une session PowerShell est de d’inclure le code.

Pour inclure un script, saisissez un point (.) suivi d’un espace avant le chemin du script. Si le script se trouve dans le dossier C:\PoshGUI-sample, vous pouvez l’inclure comme suit.

PS C:\PoshGUI-sample> . .\Main.ps1

Vous pouvez également spécifier le chemin complet si vous n’êtes pas dans le répertoire de travail actuel. Dans l’exemple de code ci-dessous, vous pouvez voir le chemin complet du script.

PS C:>. C:\PoshGUI-sample\Main.ps1

Maintenant que nous avons importé le code en mémoire, nous pouvons procéder au test de la fonction que nous avons créée. Dans l’exemple ci-dessous, on montre que la fonction Get-FixedDisk est utilisée pour interroger l’ordinateur poshLabExc.

PS51> Get-FixedDisk -Computer poshLabExc

DeviceID     : C:
DriveType    : 3
ProviderName :
FreeSpace    : 53037772800
Size         : 135838822400
VolumeName   : Windows

DeviceID     : D:
DriveType    : 3
ProviderName :
FreeSpace    : 14872641536
Size         : 17178750976
VolumeName   : Temporary Storage

DeviceID     : E:
DriveType    : 3
ProviderName :
FreeSpace    : 488202240
Size         : 524283904
VolumeName   : System Reserved

Construction de l’interface graphique PowerShell

À ce stade, vous avez créé le fichier de script nommé Main.ps1 et à l’intérieur du script, vous avez créé la fonction Get-FixedDisk. Vous avez également pu tester et confirmer que la fonction fonctionne.

Maintenant que vous savez que le script fonctionne, vous pouvez commencer à construire l’interface graphique.

Conception du formulaire de l’interface graphique PowerShell

Commencez par planifier l’apparence de l’interface graphique et les éléments que vous souhaitez utiliser. Pour cet exemple simple, notre interface graphique comportera :

  • a text box where the computer name can be entered
  • a button to execute the function
  • a text box where we can display the results

Ensuite, vous pouvez commencer à la construire!

Pour commencer à créer l’interface graphique, ouvrez Visual Studio et créez un nouveau projet.

Une fois Visual Studio ouvert, cliquez sur Fichier (1) -> Nouveau (2) -> Projet (3).

Creating a new Visual Studio project

Sous la fenêtre Nouveau projet, choisissez Visual C# (1), sélectionnez Application WPF (.NET Framework) (2), changez le nom en PoshGUI-sample (3) et cliquez sur OK.

Choosing a Visual Studio project

Une fois le projet créé, un formulaire vierge intitulé MainWindow.xaml s’affiche.

Visual Studio MainWindow.xaml

Vous devez maintenant formater ce formulaire selon nos exigences. Voici les contrôles et le format que vous devrez ajouter.

  • Fenêtre
    • Titre : Informations sur le disque
    • Hauteur : 326
    • Largeur : 403
  • Contrôles (4)
    • Étiquette
      • Contenu : « Nom de l’ordinateur : »
      • Marge : 10, 10, 0, 0
    • Zone de texte
      • Nom : txtComputer
      • Texte : «  »
      • Hauteur : 23
      • Largeur : 174
    • Bouton
      • Nom : btnQuery
      • Contenu : Interroger
      • Marge : 0, 13, 12, 0
    • Zone de texte
      • Nom : txtResults
      • Texte : «  »
      • EstEnLectureSeule : Vrai
      • Marge : 10, 60, 0, 0
      • Hauteur : 225
      • Largeur : 373

L’apparence finale du formulaire devrait être similaire à celle illustrée dans l’image ci-dessous. Vous pouvez réorganiser la disposition de votre fenêtre différemment. Soyez créatif !

PowerShell GUI Template

Combinaison du script et de l’interface utilisateur PowerShell

Une fois satisfait de votre conception, vous pouvez maintenant commencer à l’intégrer avec le script.

PowerShell ne peut pas afficher les formulaires nativement. Pour pouvoir afficher le formulaire, nous devons ajouter une ligne de code en haut de notre script pour prendre en charge le rendu du formulaire WPF.

Add-Type -AssemblyName PresentationFramework

Ensuite, ajoutez du code pour effectuer les actions suivantes:

  1. Importer et lire le code XAML du formulaire.
  2. Créer dynamiquement des variables assignées à chaque contrôle nommé
  3. Afficher le formulaire

Voici le code mis à jour à l’intérieur de votre script.

Remarque: Assurez-vous de modifier la ligne $xamlFile et de la pointer vers le chemin complet de votre fichier MainWindow.xaml.

Add-Type -AssemblyName PresentationFramework

Function Get-FixedDisk {
    [CmdletBinding()]
    # Ce bloc param() indique le début de la déclaration des paramètres
    param (
        <# 
            Ce paramètre accepte le nom de l'ordinateur cible.
            Il est également défini comme obligatoire pour que la fonction ne s'exécute pas sans spécifier la valeur.
        #>
        [Parameter(Mandatory)]
        [string]$Computer
    )
    <#
        Commande de requête WMI qui obtient la liste de tous les disques logiques et enregistre les résultats dans une variable nommée $DiskInfo
    #>
    $DiskInfo = Get-WmiObject Win32_LogicalDisk -ComputerName $Computer -Filter 'DriveType=3'
    $DiskInfo
}

# où se trouve le fichier XAML ?
$xamlFile = "C:\PoshGUI-sample\MainWindow.xaml"

# créer la fenêtre
$inputXML = Get-Content $xamlFile -Raw
$inputXML = $inputXML -replace 'mc:Ignorable="d"', '' -replace "x:N", 'N' -replace '^<Win.*', '<Window'
[XML]$XAML = $inputXML

# Lire le XAML
$reader = (New-Object System.Xml.XmlNodeReader $xaml)
try {
    $window = [Windows.Markup.XamlReader]::Load( $reader )
} catch {
    Write-Warning $_.Exception
    throw
}

# Créer des variables basées sur les noms des contrôles de formulaire.
# La variable sera nommée 'var_<nom du contrôle>'

$xaml.SelectNodes("//*[@Name]") | ForEach-Object {
    #"essayer l'élément $($_.Name)"
    try {
        Set-Variable -Name "var_$($_.Name)" -Value $window.FindName($_.Name) -ErrorAction Stop
    } catch {
        throw
    }
}
Get-Variable var_*

$Null = $window.ShowDialog()

Remarque: $Null = $window.ShowDialog() doit toujours être la dernière ligne de code à l’intérieur de votre script.

Lorsque vous exécutez ce code en exécutant le script Main.ps1, vous devriez voir la sortie d’exemple ci-dessous.

PowerShell GUI variable and field mappings

Comme vous pouvez le voir, les trois contrôles nommés ont été assignés à leurs variables. Ces noms de variables seront référencés plus tard dans le script lorsque nous ajouterons le code de logique de contrôle.

  • var_btnQuery
  • var_btnComputer
  • var_txtResults

Gardez à l’esprit que le script à ce stade ne peut afficher que le formulaire, mais les contrôles sont inutiles car vous n’avez pas encore ajouté le code.

Ajout du code de l’événement de clic sur le bouton

Maintenant que vous avez modifié avec succès le script pour importer et afficher l’interface graphique utilisateur, commencez à ajouter le code aux contrôles pour récupérer et afficher les données d’informations sur le disque.

Dans ce projet, seul le bouton btnQuery aura une action assignée. Les autres contrôles ne serviront que de contrôles d’entrée et de sortie/affichage. Cela signifie que nous devons simplement ajouter un code d’événement clic à btnQuery.

Pour ajouter l’action clic à btnQuery, assignez le code ci-dessous à sa variable correspondante $var_btnQuery. Copiez le code ci-dessous et insérez-le entre les références de code Get-Variable var_* et $Null = $window.ShowDialog() dans le script.

$var_btnQuery.Add_Click( {
   #effacer la boîte de résultat
   $var_txtResults.Text = ""
       if ($result = Get-FixedDisk -Computer $var_txtComputer.Text) {
           foreach ($item in $result) {
               $var_txtResults.Text = $var_txtResults.Text + "DeviceID: $($item.DeviceID)`n"
               $var_txtResults.Text = $var_txtResults.Text + "VolumeName: $($item.VolumeName)`n"
               $var_txtResults.Text = $var_txtResults.Text + "FreeSpace: $($item.FreeSpace)`n"
               $var_txtResults.Text = $var_txtResults.Text + "Size: $($item.Size)`n`n"
           }
       }       
   })

$var_txtComputer.Text = $env:COMPUTERNAME

Tester l’interface utilisateur PowerShell finie

Avec toutes les parties couvertes, voici le code complet de notre script qui intègre la fonction et l’interface graphique utilisateur PowerShell que nous avons conçue.

Add-Type -AssemblyName PresentationFramework

Function Get-FixedDisk {
    [CmdletBinding()]
    # Cet bloc param() indique le début de la déclaration des paramètres
    param (
        <# 
            Ce paramètre accepte le nom de l'ordinateur cible.
            Il est également défini comme obligatoire afin que la fonction ne s'exécute pas sans spécifier la valeur.
        #>
        [Parameter(Mandatory)]
        [string]$Computer
    )
    <#
        Commande de requête WMI qui obtient la liste de tous les disques logiques et enregistre les résultats dans une variable nommée $DiskInfo.
    #>
    $DiskInfo = Get-WmiObject Win32_LogicalDisk -ComputerName $Computer -Filter 'DriveType=3'
   $DiskInfo
}

#Où se trouve le fichier XAML ?
$xamlFile = "C:\Users\june\source\repos\PoshGUI-sample\PoshGUI-sample\MainWindow.xaml"

#créer une fenêtre
$inputXML = Get-Content $xamlFile -Raw
$inputXML = $inputXML -replace 'mc:Ignorable="d"', '' -replace "x:N", 'N' -replace '^<Win.*', '<Window'
[xml]$XAML = $inputXML
#Lire le XAML

$reader = (New-Object System.Xml.XmlNodeReader $xaml)
try {
    $window = [Windows.Markup.XamlReader]::Load( $reader )
}
catch {
    Write-Warning $_.Exception
    throw
}

#Créer des variables basées sur les noms des contrôles du formulaire.
#La variable sera nommée 'var_<nom du contrôle>'

$xaml.SelectNodes("//*[@Name]") | ForEach-Object {
    #"essayer l'élément $($_.Name)";
    try {
        Set-Variable -Name "var_$($_.Name)" -Value $window.FindName($_.Name) -ErrorAction Stop
    } catch {
        throw
   }
}

Get-Variable var_*

$var_btnQuery.Add_Click( {
   #effacer la boîte de résultat
   $var_txtResults.Text = ""
       if ($result = Get-FixedDisk -Computer $var_txtComputer.Text) {
           foreach ($item in $result) {
               $var_txtResults.Text = $var_txtResults.Text + "DeviceID: $($item.DeviceID)`n"
               $var_txtResults.Text = $var_txtResults.Text + "VolumeName: $($item.VolumeName)`n"
               $var_txtResults.Text = $var_txtResults.Text + "FreeSpace: $($item.FreeSpace)`n"
               $var_txtResults.Text = $var_txtResults.Text + "Size: $($item.Size)`n`n"
           }
       }       
   })

$var_txtComputer.Text = $env:COMPUTERNAME
$Null = $window.ShowDialog()

Comme vous pouvez le voir ci-dessous, après avoir appelé le script dans PowerShell, les fenêtres PowerShell GUI sont apparues. Ensuite, vous pouvez entrer un nom d’ordinateur valide pour tester la fonctionnalité.

PowerShell GUI Example Result

Vérifiez de manière sécurisée les appelants avec des méthodes d’authentification qui éliminent la possibilité d’usurpation d’identité par l’utilisateur. Bloquez les pirates du support technique avec Specops Secure Service Desk. Essayez-le gratuitement !

Résumé

Dans cet article, vous avez appris comment créer une fonction simple qui accepte une entrée et renvoie des résultats. Vous avez également appris comment créer une interface utilisateur PowerShell WPF de base ainsi que comment l’importer pour qu’elle serve de frontend au script PowerShell que vous avez créé.

Il s’agit simplement d’une combinaison de script et d’interface utilisateur de base. De nombreuses améliorations peuvent être apportées, telles que :

C’est à vous de modifier et d’ajouter des fonctionnalités en fonction de vos besoins.

Lecture complémentaire

Source:
https://adamtheautomator.com/powershell-gui/