Crea GUIs de PowerShell en WPF: Funciones, Entradas y Resultados

Tutoriales
PowerShell

PowerShell es una herramienta de línea de comandos, pero ¿sabías que también se puede utilizar como base para interfaces gráficas? A veces, la interfaz de línea de comandos no es la mejor opción para determinadas situaciones. Construir una interfaz gráfica de usuario (GUI) en PowerShell para tu servicio de asistencia técnica es un excelente ejemplo. Este es uno de esos momentos en los que es más apropiado construir herramientas gráficas.

Not a reader? Watch this related video.

Aplica la verificación del usuario final al restablecer contraseñas en el servicio de asistencia técnica. Reduce tu vulnerabilidad al ingeniería social con Specops Secure Service Desk. ¡Contáctanos para una demostración!

PowerShell puede utilizar y exponer la funcionalidad y características de .NET. Como resultado, es posible crear interfaces gráficas para los scripts que creas. La construcción de interfaces gráficas en PowerShell puede parecer complicada, especialmente si eres principiante.

Pero si tienes experiencia básica con scripts de PowerShell, no hay razón para que no aprendas y adoptes la práctica de crear GUI para tus scripts.

En esta publicación, aprenderás cómo crear una interfaz gráfica en PowerShell utilizando el Windows Presentation Framework (WPF).

Prerrequisitos

Antes de sumergirte, asegúrate de cumplir con los siguientes requisitos:

  1. Visual Studio 2017 o posterior – Lo utilizarás para crear la interfaz gráfica utilizando WPF. Puedes descargar una versión gratuita/comunitaria.
  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.

Construyendo el Script

En esta publicación, crearás un script simple llamado Main.ps1. En el script, escribirás código que extraerá información del disco de un sistema local o remoto consultando la clase WMI Win32_LogicalDisk.

Necesitarás un script para envolver primero alrededor de una interfaz gráfica de usuario (GUI). He elegido usar un script que te permite proporcionar un nombre de computadora y consultar información del disco. Esto no es necesario para construir una GUI, sin embargo. Usa las técnicas que aprendas en esta publicación para adaptar tus GUI a tus propios scripts.

Como ejemplo de script, crearé una función que realice las siguientes acciones:

  1. Aceptar la entrada para el nombre de la computadora a consultar
  2. Consultar la computadora y almacenar la información de los discos fijos en una variable
  3. Devolver los resultados

Redactando la Función

A continuación se muestra la función que utilizarás para este proyecto, adecuadamente llamada Get-FixedDisk. El propósito de este proyecto es obtener información sobre los discos no extraíbles o discos fijos en la máquina objetivo.

Aunque este fragmento de código se puede usar tal cual, sería beneficioso crear una GUI si solo quieres realizar una consulta rápida sin tener que cargar la función y escribir manualmente los comandos cada vez.

Function Get-FixedDisk {
    [CmdletBinding()]
    # Este bloque param() indica el inicio de la declaración de parámetros
    param (
        <# 
            Este parámetro acepta el nombre de la computadora de destino.
            También se establece como obligatorio para que la función no se ejecute sin especificar el valor.
        #>
        [Parameter(Mandatory)]
        [string]$Computer
    )
    <#
        Comando de consulta WMI que obtiene la lista de todos los discos lógicos y guarda los resultados en una variable llamada $DiskInfo
    #>
    $DiskInfo = Get-WmiObject Win32_LogicalDisk -ComputerName $Computer -Filter 'DriveType=3'
   $DiskInfo
}

Puedes ver que he agregado un bloque param() en el código. Esto es para instruir a la función a aceptar entradas basadas en el tipo de datos indicado.

En el ejemplo, he agregado un parámetro Computer que acepta un valor de cadena. Además, al agregar el atributo de parámetro Mandatory, asegura que la función no se ejecute si el parámetro Computer no se especifica en tiempo de ejecución.

A continuación, la línea 18 muestra el comando de consulta WMI real que obtiene la lista de todos los discos lógicos y guarda los resultados en una variable llamada $DiskInfo. También he agregado un filtro para obtener solo los discos con DriveType=3. Este filtro asegura que solo se muestre la información sobre discos fijos locales.

Importando el Código (Dot Sourcing)

En este punto, ahora tienes un script funcional y estás listo para probarlo. Pero antes de poder probar el script, necesitas importar el código en una sesión de PowerShell. Una forma de cargar código en una sesión de PowerShell es mediante el dot sourcing.

Para hacer el dot source de un script, escribe un punto (.) y un espacio antes de la ruta del script. Si el script estuviera en la carpeta C:\PoshGUI-sample, podrías hacer el dot source de la siguiente manera.

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

También puedes especificar la ruta completa si no estás en el directorio de trabajo actual. En el código de ejemplo a continuación, puedes ver la ruta completa del script.

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

Ahora que hemos importado el código en la memoria, podemos proceder a probar la función que hemos creado. En el ejemplo a continuación, se muestra que la función Get-FixedDisk se utiliza para consultar la computadora 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

Construyendo la interfaz gráfica de usuario de PowerShell

En este punto, has creado el archivo de script llamado Main.ps1 y dentro del script has creado la función Get-FixedDisk. También pudiste probar y confirmar que la función está funcionando.

Ahora que sabes que el script funciona, puedes comenzar a construir la interfaz gráfica de usuario (GUI).

Diseñando el formulario de la GUI de PowerShell

Primero, planea cómo te gustaría que se vea la GUI y los elementos que te gustaría usar. Para este ejemplo simple, nuestra GUI tendrá:

  • 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

A continuación, ¡puedes empezar a construirla!

Para comenzar a crear la GUI, abre Visual Studio y crea un nuevo proyecto.

Una vez abierto Visual Studio, haz clic en Archivo (1) –> Nuevo (2) –> Proyecto (3).

Creating a new Visual Studio project

Bajo la ventana de Nuevo Proyecto, elige Visual C# (1), selecciona Aplicación WPF (.NET Framework) (2), cambia el nombre a PoshGUI-sample (3) y haz clic en Aceptar.

Choosing a Visual Studio project

Una vez creado el proyecto, se presentará un formulario en blanco con el nombre de MainWindow.xaml.

Visual Studio MainWindow.xaml

Ahora necesitas dar formato a este formulario para que se ajuste a nuestros requisitos. A continuación se muestran los controles y el formato que necesitarás agregar.

  • Ventana
    • Título: Información del Disco
    • Altura: 326
    • Anchura: 403
  • Controles (4)
    • Etiqueta
      • Contenido: “Nombre del Equipo:”
      • Margen: 10, 10, 0, 0
    • Caja de Texto
      • Nombre: txtComputer
      • Texto: “”
      • Altura: 23
      • Anchura: 174
    • Botón
      • Nombre: btnQuery
      • Contenido: Consulta
      • Margen: 0, 13, 12, 0
    • Caja de Texto
      • Nombre: txtResults
      • Texto: “”
      • EsSoloLectura: Verdadero
      • Margen: 10, 60, 0, 0
      • Altura: 225
      • Anchura: 373

La apariencia final del formulario debería ser similar a la que se muestra en la imagen a continuación. Puedes reorganizar el diseño de tu ventana de manera diferente. ¡Sé creativo!

PowerShell GUI Template

Combinando el script y la interfaz gráfica de usuario de PowerShell

Una vez que estés satisfecho con tu diseño, ahora puedes comenzar a integrarlo con el script.

PowerShell no puede mostrar formularios de forma nativa. Para poder mostrar el formulario, necesitamos agregar una línea de código en la parte superior de nuestro script para admitir la representación del formulario WPF.

Add-Type -AssemblyName PresentationFramework

Luego, agrega código para realizar las siguientes acciones:

  1. Importar y leer el código XAML del formulario.
  2. Crear dinámicamente variables asignadas a cada control con nombre
  3. Mostrar el formulario

A continuación se muestra el código actualizado dentro de tu script.

Nota: Asegúrate de modificar la línea $xamlFile y señalar la ruta completa de tu archivo MainWindow.xaml.

Add-Type -AssemblyName PresentationFramework

Function Get-FixedDisk {
    [CmdletBinding()]
    # Este bloque param() indica el inicio de la declaración de parámetros
    param (
        <# 
            Este parámetro acepta el nombre del equipo de destino.
            También se establece como obligatorio para que la función no se ejecute sin especificar el valor.
        #>
        [Parameter(Mandatory)]
        [string]$Computer
    )
    <#
        Comando de consulta de WMI que obtiene la lista de todos los discos lógicos y guarda los resultados en una variable llamada $DiskInfo
    #>
    $DiskInfo = Get-WmiObject Win32_LogicalDisk -ComputerName $Computer -Filter 'DriveType=3'
    $DiskInfo
}

# ¿Dónde está el archivo XAML?
$xamlFile = "C:\PoshGUI-sample\MainWindow.xaml"

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

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

# Crear variables basadas en los nombres de los controles del formulario.
# La variable se nombrará como 'var_<nombre del control>'

$xaml.SelectNodes("//*[@Name]") | ForEach-Object {
    #"intentando 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() siempre debe ser la última línea de código dentro de tu script.

Cuando ejecutes este código mediante la ejecución del script Main.ps1, deberías ver el ejemplo de salida a continuación.

PowerShell GUI variable and field mappings

Como puedes ver, los tres controles nombrados fueron asignados a sus variables. Estos nombres de variables se referenciarán más adelante en el script cuando agreguemos el código de lógica de control.

  • var_btnQuery
  • var_btnComputer
  • var_txtResults

Ten en cuenta que en este punto, el script solo puede mostrar el formulario, pero los controles son inútiles ya que aún no has agregado el código.

Agregando el Código del Evento de Clic del Botón

Ahora que has modificado con éxito el script para importar y mostrar la interfaz gráfica, comienza a agregar el código a los controles para recuperar y mostrar los datos de información del disco.

En este proyecto, solo el botón btnQuery se le asignará una acción. Los otros controles solo servirán como controles de entrada y salida/mostrador. Esto significa que solo necesitamos agregar un código de evento clic a btnQuery.

Para agregar la acción de clic a btnQuery, asigna el siguiente código a su nombre de variable correspondiente $var_btnQuery. Copia el código a continuación e insértalo entre las referencias de código Get-Variable var_* y $Null = $window.ShowDialog() en el script.

$var_btnQuery.Add_Click( {
   #limpia el cuadro de resultados
   $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

Probando la GUI de PowerShell Terminada

Con todas las partes cubiertas, a continuación se muestra el código completo de nuestro script que incorpora la función y la interfaz gráfica de PowerShell que hemos diseñado.

Add-Type -AssemblyName PresentationFramework

Function Get-FixedDisk {
    [CmdletBinding()]
    # Este bloque param() indica el inicio de la declaración de parámetros
    param (
        <# 
            Este parámetro acepta el nombre del equipo de destino.
            También se establece como obligatorio para que la función no se ejecute sin especificar el valor.
        #>
        [Parameter(Mandatory)]
        [string]$Computer
    )
    <#
        Comando de consulta WMI que obtiene la lista de todos los discos lógicos y guarda los resultados en una variable llamada $DiskInfo
    #>
    $DiskInfo = Get-WmiObject Win32_LogicalDisk -ComputerName $Computer -Filter 'DriveType=3'
   $DiskInfo
}

#¿Dónde está el archivo XAML?
$xamlFile = "C:\Users\june\source\repos\PoshGUI-sample\PoshGUI-sample\MainWindow.xaml"

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

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

#Crear variables basadas en nombres de controles de formulario.
#La variable se nombrará como 'var_<nombre del control>'

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

Get-Variable var_*

$var_btnQuery.Add_Click( {
   #borrar el cuadro de resultados
   $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()

Como se puede ver a continuación, después de llamar al script en PowerShell, aparecieron las ventanas GUI de PowerShell. Luego, puede ingresar un nombre de equipo válido para probar la funcionalidad.

PowerShell GUI Example Result

Verifique de manera segura a los llamadores con métodos de autenticación que eliminen la oportunidad de suplantación de usuario. Bloquee a los hackers de helpdesk con Specops Secure Service Desk. ¡Pruébalo gratis!

Resumen

En este artículo, aprendiste cómo crear una función simple que acepta entrada y devuelve resultados. También aprendiste cómo crear una interfaz gráfica de usuario básica de PowerShell de WPF, así como cómo importarla para que actúe como un front-end para el script de PowerShell que creaste.

Esto es solo una combinación básica de script e interfaz gráfica de usuario. Se pueden hacer numerosas mejoras, tales como:

  • Formatear el tamaño y el espacio libre para mostrarlos como valores de GB.
  • Cambiar el nombre de la propiedad mostrada.
  • Usar GridView en lugar de TextBox para mostrar los resultados.
  • Agregar un botón de importación para recorrer una lista de servidores desde un archivo CSV.

Depende de ti modificar y agregar funcionalidades según tus requisitos.

Lecturas adicionales

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