Getty Images

Ratgeber

Codebeispiele für die GUI-Erstellung für PowerShell-Skripte

PowerShell-Skripte können mühsam zu schreiben und schwierig zu verwenden sein. Mit diesen einfach zu befolgenden Befehlen erstellen Teams GUIs für ihre PowerShell-Skripte.

Brien Posey
von
Zuletzt aktualisiert:08 März 2024

Obwohl PowerShell eine Befehlszeilenumgebung ist, ist es möglich, GUI-basierte PowerShell-Skripte zu erstellen. Mit Beispielen, die von einfach bis komplex reichen, können GUI-basierte PowerShell-Skripte eine großartige Ergänzung zu den PowerShell-Strategien jedes Teams sein.

Aus IT-Sicht gibt es zwei Hauptgründe, warum Sie eine grafische Benutzeroberfläche (GUI) für ein PowerShell-Skript erstellen sollten. Erstens: Wenn Sie regelmäßig ein bestimmtes PowerShell-Cmdlet verwenden, das mehrere Parameter erfordert, können Sie eine grafische Benutzeroberfläche als Alternative zur mühsamen Eingabe verwenden.

Beispielsweise kann eine grafische Benutzeroberfläche den Prozess der Erstellung einer Hyper-V-VM vereinfachen. Normalerweise muss das Cmdlet New-VM eingegeben werden, gefolgt von mehreren Parametern. Die grafische Benutzeroberfläche kann den Benutzer jedoch zur Eingabe der erforderlichen Informationen auffordern und diese Informationen dann im Hintergrund an das Cmdlet New-VM übermitteln, wodurch der VM-Erstellungsprozess automatisiert wird.

GUI-basierte PowerShell-Skripte werden auch häufig verwendet, wenn die IT-Abteilung ein Skript erstellen muss, das von Personen außerhalb der IT-Abteilung verwendet wird. Die Implementierung einer grafischen Benutzeroberfläche verbessert die Benutzerfreundlichkeit des Skripte und macht es für Nicht-IT-Mitarbeiter leichter zugänglich.

In diesem Ratgeber werden zwei Beispiele behandelt: die Erstellung einfacher PowerShell-GUIs und der komplexere Prozess der Verwendung einer PowerShell-GUI zur Erstellung einer Hyper-V-VM. Durch die Befolgung dieser Schritte und Befehle können Teams die Erstellung von PowerShell-Skripten rationalisieren und einen zeitaufwendigen und komplexen Prozess in einen effizienten und unkomplizierten Prozess verwandeln.

So erstellen Sie eine PowerShell-GUI

Obwohl GUI-basierte PowerShell-Skripte oft komplex sind, ist es relativ einfach, eine einfache GUI zu erstellen. Lassen Sie uns ein einfaches Skript erstellen, das die Worte Hello World in einem Textfeld innerhalb einer GUI anzeigt.

1. Erforderliche Assemblies laden

Der erste Schritt beim Erstellen eines GUI-basierten PowerShell-Skripte besteht darin, die erforderlichen Assemblies zu laden. Laden Sie die System.Windows.Forms-Assembly und die System.Drawing-Assembly mit den folgenden Befehlen.

Add-Type -AssemblyName System.Windows.Forms
Add-Type -AssemblyName System.Drawing

2. GUI-Schnittstellenelemente erstellen

Als nächstes erstellen Sie die einzelnen Oberflächenelemente, die Sie innerhalb der GUI verwenden werden. Dazu können Beschriftungen (Text), Textfelder, Kombinationsfelder (Menüs), Schaltflächen oder andere grafische Elemente gehören.

Obwohl die genauen Codezeilen je nach dem von Ihnen erstellten GUI-Element variieren, ist der grundlegende Prozess für die meisten GUI-Elemente derselbe. Der folgende Beispielcodeblock verdeutlicht den grundlegenden Prozess.

$OutputBox = New-Object System.Windows.Forms.textbox
$OutputBox.Text = "Hello World"
$OutputBox.Multiline = $False
$OutputBox.Size = New-Object System.Drawing.Size(100,100)
$OutputBox.Location = new-object System.Drawing.Size(20,80)

Um ein Element der GUI-Oberfläche zu definieren, erstellen Sie eine Variable, die dieses Element darstellt. In diesem Beispiel stellt die Variable ein Textbox-Objekt dar, da die Variable $OutputBox aufgerufen und ihr der Wert New-Object System.Windows.Forms.textbox zugewiesen wird.

3. Definieren Sie Elementattribute

Sobald ein Elementobjekt der GUI-Schnittstelle definiert haben, müssen Sie diesem Objekt verschiedene Attribute zuweisen. Diese Attribute können Dinge wie die Größe, Farbe, Position oder Schriftart des Objekts beinhalten.

Viele der verfügbaren Attribute sind optional, aber Sie müssen fast immer die Größe und Position des Objekts festlegen. Die Position bezieht sich auf die linke, obere Ecke des GUI-Fensters. In meinem Beispielcodeblock befindet sich das Objekt 20 Pixel rechts von und 80 Pixel unterhalb der linken oberen Ecke des Fensters. Die Größe ist auf 100 Pixel Breite und 100 Pixel Höhe eingestellt.

Das Beispiel ist ein einzeiliges Textfeld, weil $OutputBox.Multiline auf False gesetzt ist. Daher ignoriert Windows die Höhe des Textfeldes und macht das Textfeld einfach so hoch, wie es sein muss, um eine einzelne Textzeile unterzubringen.

4. Erstellen Sie ein Formularobjekt

Als nächstes erstellen Sie ein Formularobjekt. Das Formular ist im Wesentlichen die grafische Benutzeroberfläche: es ist im Grunde eine leere Leinwand. Der folgende Codeblock veranschaulicht den Prozess der Formularerstellung.

$Form = New-Object Windows.Forms.Form
$Form.Text = "Posey's Example GUI"
$Form.Width = 300
$Form.Height = 200
$Form.BackColor="LightBlue"

Hier habe ich ein Formularobjekt erstellt und es mit einer Variablen namens $Form verknüpft. Die Größe des Formulars ist 300 Pixel breit und 200 Pixel hoch. Ich habe mich außerdem dafür entschieden, das Formular hellblau zu färben und dem Fenster den Namen Posey’s Example GUI zu geben.

Nachdem Sie nun das Formular definiert haben, weisen Sie PowerShell an, die einzelnen GUI-Elemente zum Formular hinzuzufügen. In diesem Fall habe ich ein einzelnes GUI-Element namens $OutputBox. Sie können es dem Formular mit dem folgenden Befehl hinzufügen.

$Form.Controls.add($OutputBox)

5. Aktivieren Sie die Form

Der letzte Schritt des Prozesses ist die Aktivierung und Anzeige der Form. Sie können das mit den folgenden Codezeilen tun:

$Form.Add_Shown({$Form.Activate()})
$Form.ShowDialog()
Ergebnis
Abbildung 1: Wenn Sie den Beispielcode und die Schritte befolgen, erhalten Sie dieses Ergebnis.

Verwenden der PowerShell-GUI zum Erstellen einer Hyper-V-VM

Nachdem Sie gelernt haben, wie man eine grundlegende PowerShell-GUI erstellt, können Sie komplexere Skripte üben, zum Beispiel die Verwendung einer GUI zum Erstellen einer Hyper-V-VM. In diesem Beispiel wird zwar keine umfassende Oberfläche erstellt, die alle Hyper-V-Optionen zur Verfügung stellt, aber es wird gezeigt, wie eine GUI zur Vereinfachung einer Verwaltungsaufgabe verwendet werden kann.

Beispiel für ein GUI-basiertes Skript
Abbildung 2: Das ist ein Beispiel für ein GUI-basiertes Skript für administrative Aufgaben.

Wie in Abbildung 2 dargestellt, fordert das Skript den Benutzer auf, einen Namen für seine neue VM einzugeben und die Menge des Memorys, die die VM verwenden wird, sowie die Größe der virtuellen Festplatte anzugeben.

Alle Felder sind vorausgefüllt, aber der Benutzer kann andere Werte eingeben. Sobald der Benutzer seine bevorzugten Werte eingegeben hat, klickt er einfach auf die Schaltfläche Submit (Senden). Dann werden die Felder geleert und die VM wird erstellt, wie in Abbildung 3 dargestellt.

Durch GUI erstellte VM
Abbildung 3: Die GUI erstellt die VM.

Auf struktureller Ebene funktioniert dieses Skript ähnlich wie das Beispiel Hello World. Der größte Unterschied besteht darin, dass ich viel mehr GUI-Schnittstellenelemente definiert habe. Der gesamte Text, der innerhalb der grafischen Benutzeroberfläche erscheint, wird durch Label-Objekte gesteuert. Außerdem gibt es zwei Textfelder für die Eingabe des VM-Namens und der Größe der virtuellen Festplatte. Die GUI enthält auch ein Kombinationsfeld zur Auswahl der Memory-Größe und eine Schaltfläche Submit (Senden).

Wenn Sie ein Schaltflächenobjekt erstellen, müssen Sie in der Regel eine Klickaktion mit der Schaltfläche verknüpfen, um PowerShell mitzuteilen, was geschehen soll, wenn auf die Schaltfläche geklickt wird. In diesem Fall enthält die Klickaktion mehrere Codezeilen, die die Werte abrufen, die in die grafische Benutzeroberfläche eingegeben wurden, und diese Werte in ein normalisiertes Format bringen.

Von dort aus erstellt das Skript eine Zeichenfolge, die den zur Erstellung der VM verwendeten Befehl nachahmt. Sie können dann den Befehl Invoke-Expression verwenden, um den Inhalt der Zeichenfolge auszuführen.

Sie können den vollständigen Code unten einsehen.

Add-Type -AssemblyName System.Windows.Forms
Add-Type -AssemblyName System.Drawing

$GreetingLabel = New-Object Windows.Forms.Label
$GreetingLabel.Text = "Hyper-V VM Creation Utility"
$GreetingLabel.Font = New-Object Drawing.Font("Arial", 24, [Drawing.FontStyle]::Bold)
$GreetingLabel.AutoSize = $true
$GreetingLabel.Location = New-Object Drawing.Point(10,10)
$GreetingLabel.ForeColor = [System.Drawing.Color]::Black

$VMNameBox = New-Object System.Windows.Forms.textbox
$VMNameBox.Text = "NewVM"
$VMNameBox.Multiline = $False
$VMNameBox.Size = New-Object System.Drawing.Size(100,100)
$VMNameBox.Location = new-object System.Drawing.Size(10,150)

$VMNameLabel = New-Object Windows.Forms.Label
$VMNameLabel.Text = "Virtual Machine Name"
$VMNameLabel.AutoSize = $true
$VMNameLabel.Location = New-Object Drawing.Point(10,180)
$VMNameLabel.ForeColor = [System.Drawing.Color]::Black

$MemoryComboBox = New-Object system.Windows.Forms.ComboBox
$MemoryComboBox.text = ""
$MemoryComboBox.width = 100
$MemoryComboBox.autosize = $true
$MemoryComboBox.location = New-Object System.Drawing.Point(200,170)
# Add the items in the dropdown list
@(2,4,6,8,10,12,14,16) | ForEach-Object {[void] $MemoryComboBox.Items.Add($_)}
# Select the default value
$MemoryComboBox.SelectedIndex = 0

$MemoryLabel = New-Object Windows.Forms.Label
$MemoryLabel.Text = "Memory (GB)"
$MemoryLabel.AutoSize = $true
$MemoryLabel.Location = New-Object Drawing.Point(200,150)
$MemoryLabel.ForeColor = [System.Drawing.Color]::Black

$VHDSizeBox = New-Object System.Windows.Forms.textbox
$VHDSizeBox.Text = 40
$VHDSizeBox.Multiline = $False
$VHDSizeBox.Size = New-Object System.Drawing.Size(100,100)
$VHDSizeBox.Location = new-object System.Drawing.Size(10,220)

$VHDSizeLabel = New-Object Windows.Forms.Label
$VHDSizeLabel.Text = "Virtual Hard Disk Size (GB)"
$VHDSizeLabel.AutoSize = $true
$VHDSizeLabel.Location = New-Object Drawing.Point(10,250)
$VHDSizeLabel.ForeColor = [System.Drawing.Color]::Black

$CreateButton = New-Object System.Windows.Forms.Button
$CreateButton.Location = New-Object System.Drawing.Size (200,220)
$CreateButton.Size = New-Object System.Drawing.Size(160,30)
$CreateButton.Font=New-Object System.Drawing.Font("Lucida Console",18,[System.Drawing.FontStyle]::Regular)
$CreateButton.BackColor = "LightGray"
$CreateButton.Text = "Submit"
$CreateButton.Add_Click({

	#Get VM Name
	$VMName=$VMNameBox.Text
	$VMNameBox.Text=""


	#Get VM Memory
	$Index=$MemoryComboBox.SelectedIndex
	[String]$VMMem=$MemoryComboBox.Items[$Index]
	$VMMem=$VMMem + "GB"
	$Index=$MemoryComboBox.SelectedIndex=0

	#Get Virtual Hard Disk Size
	[String]$VHDX = $VHDSizeBox.Text
	$VHDX = $VHDX + "GB"
	$VHDSizeBox.Text = ""

	#Create VHD Path
	$VHDPath="C:\temp\" + $VMName + ".VHDX"

	#Form VM Creation Command
	[String]$NewVMCommand = "New-VM -Name $VMName -MemoryStartupBytes $VMMem -NewVHDPath $VHDPath -NewVHDSizeBytes $VHDX"

	#Create Virtual Machine
	Invoke-Expression $NewVMCommand
	})

$Form = New-Object Windows.Forms.Form
$Form.Text = "VM Creation Tool"
$Form.Width = 550
$Form.Height = 350
$Form.BackColor="LightBlue"

$Form.Controls.add($GreetingLabel)
$Form.Controls.add($VMNameBox)
$Form.Controls.add($VMNameLabel)
$Form.Controls.add($VHDSizeBox)
$Form.Controls.add($VHDSizeLabel)
$Form.Controls.add($MemoryComboBox)
$Form.Controls.add($MemoryLabel)
$Form.Controls.add($CreateButton)
$Form.Add_Shown({$Form.Activate()})
$Form.ShowDialog()

Erfahren Sie mehr über Server- und Desktop-Virtualisierung