Crea GUI PowerShell WPF: Funzioni, Input e Risultati

Tutorial
PowerShell

PowerShell è uno strumento a riga di comando, ma sai che può essere utilizzato anche come base per interfacce grafiche? A volte, la riga di comando non è il tipo di interfaccia migliore per una determinata situazione. La creazione di un’interfaccia utente grafica PowerShell per il tuo service desk è un ottimo esempio. Questo è uno di quei momenti in cui è più appropriato creare strumenti grafici.

Not a reader? Watch this related video.

Applica la verifica dell’utente finale durante il ripristino delle password presso il desk di assistenza. Riduci la tua vulnerabilità all’ingegneria sociale con Specops Secure Service Desk. Contattaci per una demo!

PowerShell può utilizzare ed esporre funzionalità e caratteristiche di .NET. Di conseguenza, è possibile scrivere interfacce grafiche per gli script che crei. La creazione di interfacce grafiche PowerShell può sembrare complicata, specialmente se sei un principiante.

Ma se hai una conoscenza di base dello scripting PowerShell, non c’è motivo per cui tu non possa imparare e adattare la pratica di creare interfacce grafiche per i tuoi script.

In questo post, imparerai come creare un’interfaccia grafica PowerShell utilizzando il framework di presentazione di Windows (WPF).

Prerequisiti

Prima di iniziare, assicurati di soddisfare i seguenti requisiti:

  1. Visual Studio 2017 o successivo – Lo utilizzerai per creare l’interfaccia utente grafica utilizzando WPF. Puoi scaricare una versione gratuita/community.
  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.

Costruzione dello script

In questo post, creerai uno script semplice chiamato Main.ps1.Nello script, scriverai del codice per estrarre le informazioni sul disco da un sistema locale o remoto interrogando la classe WMI Win32_LogicalDisk.

Avrai bisogno di uno script per avvolgere una GUI all’inizio. Ho scelto di utilizzare uno script che ti consente di fornire un nome di computer e interrogare le informazioni sul disco. Questo non è assolutamente necessario per creare una GUI, però. Utilizza le tecniche apprese in questo post per adattare le tue GUI ai tuoi script personali.

Come esempio di script, creerò una funzione che esegue le seguenti azioni:

  1. Accetta l’input per il nome del computer da interrogare
  2. Interroga il computer e memorizza le informazioni sui dischi fissi in una variabile
  3. Restituisci i risultati

Scrittura della funzione

Di seguito è riportata la funzione che userai per questo progetto, chiamata in modo appropriato Get-FixedDisk. Lo scopo di questo progetto è ottenere le informazioni sui dischi non rimovibili o fissi sulla macchina di destinazione.

Anche se questo pezzo di codice può essere utilizzato così com’è, sarebbe utile creare una GUI se desideri eseguire una query rapida senza dover puntare la funzione e digitare manualmente i comandi ogni volta.

Function Get-FixedDisk {
    [CmdletBinding()]
    # Questo blocco param() indica l'inizio della dichiarazione dei parametri
    param (
        <# 
            Questo parametro accetta il nome del computer di destinazione.
            È anche impostato come obbligatorio in modo che la funzione non venga eseguita senza specificare il valore.
        #>
        [Parameter(Mandatory)]
        [string]$Computer
    )
    <#
        Comando di query WMI che ottiene l'elenco di tutti i dischi logici e salva i risultati in una variabile chiamata $DiskInfo
    #>
    $DiskInfo = Get-WmiObject Win32_LogicalDisk -ComputerName $Computer -Filter 'DriveType=3'
   $DiskInfo
}

È possibile notare che ho aggiunto un blocco param() nel codice. Questo serve per istruire la funzione ad accettare input in base al tipo di dati indicato.

Nell’esempio, ho aggiunto un parametro Computer che accetta un valore di stringa. Inoltre, aggiungendo l’attributo del parametro Mandatory, si garantisce che la funzione non venga eseguita se il parametro Computer non viene specificato durante l’esecuzione.

Successivamente, la riga 18 mostra il comando di query WMI effettivo che ottiene l’elenco di tutti i dischi logici e salva i risultati in una variabile chiamata $DiskInfo. Ho anche aggiunto un filtro per ottenere solo i dischi con DriveType=3. Questo filtro assicura che venga visualizzata solo l’informazione sui dischi fissi locali.

Importazione del Codice (Dot Sourcing)

In questo momento, hai uno script funzionante e sei pronto per testarlo. Ma prima di poter testare lo script, è necessario importare il codice in una sessione PowerShell. Un modo per caricare il codice in una sessione PowerShell è tramite il sourcing del punto.

Per fare il dot source di uno script, digita un punto (.) seguito da uno spazio prima del percorso dello script. Se lo script si trovasse nella cartella C:\PoshGUI-sample, potresti eseguire il dot source come indicato di seguito.

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

Puoi anche specificare il percorso completo se non sei nella directory di lavoro corrente. Nell’esempio di codice seguente, puoi vedere il percorso completo dello script.

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

Ora che abbiamo importato il codice nella memoria, possiamo procedere con il test della funzione che abbiamo creato. Nell’esempio seguente, si mostra che la funzione Get-FixedDisk viene utilizzata per interrogare il computer 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

Costruzione dell’interfaccia grafica di PowerShell

A questo punto, hai creato il file di script chiamato Main.ps1, e all’interno dello script hai creato la funzione Get-FixedDisk. Sei anche riuscito a testare e confermare che la funzione funziona.

Ora che sai che lo script funziona, puoi iniziare a costruire l’interfaccia grafica utente (GUI).

Progettare il modulo della GUI di PowerShell

Prima pianifica come desideri che appaia la GUI e gli elementi che vuoi utilizzare. Per questo semplice esempio, la nostra GUI avrà:

  • 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

Successivamente, puoi iniziare a costruirla!

Per iniziare a creare la GUI, apri Visual Studio e crea un nuovo progetto.

Una volta aperto Visual Studio, fare clic su File (1) –> Nuovo (2) –> Progetto (3).

Creating a new Visual Studio project

Sotto la finestra Nuovo progetto, scegliere Visual C# (1), selezionare Applicazione WPF (.NET Framework) (2), cambiare il nome in PoshGUI-sample (3) e fare clic su OK.

Choosing a Visual Studio project

Una volta creato il progetto, verrà presentato un modulo vuoto con il nome di MainWindow.xaml.

Visual Studio MainWindow.xaml

Ora è necessario formattare questo modulo per soddisfare i nostri requisiti. Di seguito sono riportati i controlli e il formato che è necessario aggiungere.

  • Finestra
    • Titolo: Informazioni sul disco
    • Altezza: 326
    • Larghezza: 403
  • Controlli (4)
    • Etichetta
      • Contenuto: “Nome computer:”
      • Margine: 10, 10, 0, 0
    • Casella di testo
      • Nome: txtComputer
      • Testo: “”
      • Altezza: 23
      • Larghezza: 174
    • Pulsante
      • Nome: btnQuery
      • Contenuto: Query
      • Margine: 0, 13, 12, 0
    • Casella di testo
      • Nome: txtResults
      • Testo: “”
      • SolaLettura: Vero
      • Margine: 10, 60, 0, 0
      • Altezza: 225
      • Larghezza: 373

L’aspetto finale del modulo dovrebbe essere simile a quello mostrato nell’immagine sottostante. Puoi riorganizzare il layout della finestra in modo diverso. Sii creativo!

PowerShell GUI Template

Combina lo script e l’interfaccia utente di PowerShell

Una volta soddisfatto del tuo design, puoi iniziare ad integrarlo con lo script.

PowerShell non può visualizzare moduli nativamente. Per poter visualizzare il modulo, è necessario aggiungere una riga di codice all’inizio dello script per supportare il rendering del modulo WPF.

Add-Type -AssemblyName PresentationFramework

Quindi aggiungi il codice per eseguire le seguenti azioni:

  1. Importa e leggi il codice XAML del modulo.
  2. Crea dinamicamente variabili assegnate a ciascun controllo con nome
  3. Visualizza il modulo

Di seguito è riportato il codice aggiornato all’interno del tuo script.

Nota: Assicurati di modificare la riga $xamlFile e indicare il percorso completo del tuo file MainWindow.xaml.

Add-Type -AssemblyName PresentationFramework

Function Get-FixedDisk {
    [CmdletBinding()]
    # Questo blocco param() indica l'inizio della dichiarazione dei parametri
    param (
        <# 
            Questo parametro accetta il nome del computer di destinazione.
            È anche impostato come obbligatorio in modo che la funzione non venga eseguita senza specificare il valore.
        #>
        [Parameter(Mandatory)]
        [string]$Computer
    )
    <#
        Comando di query WMI che ottiene l'elenco di tutti i dischi logici e salva i risultati in una variabile chiamata $DiskInfo
    #>
    $DiskInfo = Get-WmiObject Win32_LogicalDisk -ComputerName $Computer -Filter 'DriveType=3'
    $DiskInfo
}

# dove si trova il file XAML?
$xamlFile = "C:\PoshGUI-sample\MainWindow.xaml"

#crea finestra
$inputXML = Get-Content $xamlFile -Raw
$inputXML = $inputXML -replace 'mc:Ignorable="d"', '' -replace "x:N", 'N' -replace '^<Win.*', '<Window'
[XML]$XAML = $inputXML

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

# Crea variabili basate sui nomi dei controlli del modulo.
# La variabile sarà chiamata 'var_<nome del controllo>'

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

$Null = $window.ShowDialog()

Nota: $Null = $window.ShowDialog() deve sempre essere l’ultima riga di codice all’interno dello script.

Quando esegui questo codice eseguendo lo script Main.ps1, dovresti vedere l’esempio di output di seguito.

PowerShell GUI variable and field mappings

Come puoi vedere, ai tre controlli denominati sono stati assegnate le loro variabili. Questi nomi di variabili saranno richiamati successivamente nello script quando aggiungeremo il codice della logica di controllo.

  • var_btnQuery
  • var_btnComputer
  • var_txtResults

Tieni presente che allo stato attuale lo script può solo visualizzare il modulo, ma i controlli sono inutili poiché non hai ancora aggiunto il codice.

Aggiunta del codice per l’evento di clic del pulsante

Ora che hai modificato con successo lo script per importare e visualizzare l’interfaccia utente, inizia ad aggiungere il codice ai controlli per recuperare e visualizzare i dati delle informazioni sul disco.

In questo progetto, solo il pulsante btnQuery sarà associato a un’azione. Gli altri controlli fungeranno solo da controlli di input e output/visualizzazione. Ciò significa che è sufficiente aggiungere un codice di evento clic a btnQuery.

Per aggiungere l’azione clic a btnQuery, assegna il codice qui sotto al suo corrispondente nome di variabile $var_btnQuery. Copia il codice qui sotto e inseriscilo tra i riferimenti di codice Get-Variable var_* e $Null = $window.ShowDialog() nello script.

$var_btnQuery.Add_Click( {
   #svuota la casella dei risultati
   $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

Testare l’interfaccia utente di PowerShell finita

Con tutte le parti coperte, di seguito è riportato il codice completo per il nostro script che incorpora la funzione e l’interfaccia utente di PowerShell che abbiamo progettato.

Add-Type -AssemblyName PresentationFramework

Function Get-FixedDisk {
    [CmdletBinding()]
    # Questo blocco param() indica l'inizio della dichiarazione dei parametri
    param (
        <# 
            Questo parametro accetta il nome del computer di destinazione.
            È anche impostato come obbligatorio in modo che la funzione non venga eseguita senza specificare il valore.
        #>
        [Parameter(Mandatory)]
        [string]$Computer
    )
    <#
        Comando di query WMI che ottiene l'elenco di tutti i dischi logici e salva i risultati in una variabile chiamata $DiskInfo
    #>
    $DiskInfo = Get-WmiObject Win32_LogicalDisk -ComputerName $Computer -Filter 'DriveType=3'
   $DiskInfo
}

#dov'è il file XAML?
$xamlFile = "C:\Users\june\source\repos\PoshGUI-sample\PoshGUI-sample\MainWindow.xaml"

#crea finestra
$inputXML = Get-Content $xamlFile -Raw
$inputXML = $inputXML -replace 'mc:Ignorable="d"', '' -replace "x:N", 'N' -replace '^<Win.*', '<Window'
[xml]$XAML = $inputXML
#Leggi XAML

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

#Crea variabili basate sui nomi dei controlli del modulo.
#La variabile verrà denominata 'var_<nome controllo>'

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

Get-Variable var_*

$var_btnQuery.Add_Click( {
   #pulisci la casella dei risultati
   $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()

Come puoi vedere di seguito, dopo aver chiamato lo script in PowerShell, sono apparse le finestre GUI di PowerShell. Quindi sei in grado di inserire un nome computer valido per testare la funzionalità.

PowerShell GUI Example Result

Verifica in modo sicuro i chiamanti con metodi di autenticazione che eliminano l’opportunità di impersonificazione dell’utente. Blocca gli hacker del servizio di assistenza con Specops Secure Service Desk. Provalo gratuitamente!

Riepilogo

In questo articolo, hai imparato come creare una semplice funzione che accetta input e restituisce risultati. Hai anche imparato come creare un’interfaccia grafica di base WPF PowerShell e come importarla per agire come front-end per lo script PowerShell che hai creato.

Questo è solo una combinazione di script e GUI di base. Numerosi miglioramenti possono essere fatti come:

  • Formattare la dimensione e lo spazio libero per visualizzarli come valori GB.
  • Cambiare il nome della proprietà visualizzata.
  • Usare GridView invece di TextBox per mostrare i risultati.
  • Aggiungere un pulsante di importazione per scorrere una lista di server da un file CSV.

È a tua discrezione modificare e aggiungere funzionalità in base alle tue esigenze.

Ulteriori letture

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