Windows PowerShell con WPF

Secretos para crear una aplicación WPF en Windows PowerShell

Doug Finke

Descargar el ejemplo de código

Windows PowerShell entrega una nueva dimensión en la automatización de las tareas. Más que desplazar las antiguas tecnologías, las amplifica. El uso de Windows PowerShell (PowerShell de ahora en adelante por motivos de brevedad) no significa que haya que rehacer todas las aplicaciones para poder aprovecharlo. Todo lo contrario, PowerShell se integra perfectamente con las herramientas y procesos existentes y los extiende.

PowerShell es una tecnología de automatización compuesta de una interfaz de línea de comandos (CLI), un lenguaje de scripting y una API.

En este artículo realizaré un recorrido a través de las técnicas clave de PowerShell y crearé una herramienta para calcular el valor actual (bit.ly/7oEij1) con una interfaz gráfica de usuario (GUI) de Windows Presentation Foundation (WPF) (consulte la Figura 1).

Figura 1 La calculadora del valor actual en PowerShell

Presentaré varios elementos claves de PowerShell: WPF PowerShell Kit (WPK), la canalización de objetos, funciones, la clase PSObject y sus propiedades, integración con Microsoft .NET Framework, módulos, y más.

PowerShell se basa en .NET Framework, lo que permite acceder al marco en forma armoniosa, como con cualquier otro lenguaje .NET. Además proporciona acceso al resto del sistema operativo Windows y sus componentes, tales como servicios, procesos y el Instrumental de administración de Windows (WMI) y acceder a servidores remotos (que también tienen habilitada la versión 2 de PowerShell y la Administración remota de Windows).

Todo esto se logra gracias al nuevo lenguaje de scripting expuesto por PowerShell. No se necesita más que el Bloc de notas y algunos cmdlets de PowerShell (pronunciado en inglés “command lets”, un cmdlet es un comando ligero que se usa en el entorno de PowerShell). Lo bueno es que todo esto ya está listo para usar. Los cmdlets están integrados en PowerShell, y el Bloc de notas viene con Windows. Los tres cmdlets clave son: Get-Help, que muestra información acerca de los comandos y conceptos de PowerShell; Get-Command, que obtiene información elemental sobre los cmdlets y otros elementos de los comandos de PowerShell y Get-Member, que obtiene los “miembros” (propiedades y métodos) de los objetos.

Todo está en descubrir los elementos y las funciones, y estos cmdlets facilitan la navegación de esta plataforma de automatización de tareas.

Partamos por el principio

Pregunta: ¿cuántas líneas de código se necesitan para crear una aplicación WPF con un rótulo que diga “Hola a todos”?

Respuesta: dos, si se usa PowerShell y WPK, como se puede observar en la Figura 2.

Figura 2 Una aplicación WPF de dos líneas en PowerShell

Esto es una aplicación WPF escrita en dos líneas de PowerShell. La primera línea, Import-Module WPK, importa el paquete WPK que contiene un conjunto de cmdlets para PowerShell que encapsula a WPF. Curiosamente, para que esto funcione no se necesita ni VisualStudio, XAML ni C#. Pero sí hay que instalar WPK (consulte la siguiente sección).

PowerShell (versión 2) está listo para usar en Windows 7 y Windows Server 2008 R2 (y se puede descargar para las últimas versiones de Windows). PowerShell Pack se publicó junto con los sistemas operativos de cliente y servidor (como descarga separada que incluye WPK). Es un reconocimiento a la herramienta de scripting Tcl/Tk tan popular en Unix.

Comenzaré por crear la aplicación a partir de un conjunto sencillo de variables en PowerShell, y la extenderé hasta convertirla en una aplicación WPF interactiva. Emplearé el Entorno de scripting integrado (ISE) de PowerShell.

¿Desea seguir los pasos?

Si tiene Windows 7 ya está casi preparado para comenzar (recuerde, PowerShell viene integrado en esta versión).

Si no tiene Windows 7, descargue e instale PowerShell para los sistemas operativos más antiguos. Asegúrese de elegir la descarga para el sistema operativo correcto. Vea el paquete Windows Management Framework Core (bit.ly/9POYjq).

Independientemente de la versión de su sistema operativo, tiene que descargar e instalar WPK (bit.ly/dFVpfL). Forma parte del kit de recursos de Windows 7 y contiene nueve módulos adicionales de PowerShell, incluidos el ISE Pack para usarlo en el entorno de scripting integrado de PowerShell. El ISE está disponible de modo predeterminado en PowerShell versión 2. ISE Pack también es un excelente recurso para aprender, ya que muestra cómo personalizar los diferentes niveles del ISE.

Una vez que haya iniciado PowerShell, ejecute este cmdlet: Set-ExecutionPolicy RemoteSigned. PowerShell está configurado para no ejecutar scripts de manera predeterminada. Esta es una medida de seguridad y al principio todos los usuarios de PowerShell deben cambiar esta configuración. Para que Set-ExecutionPolicy funcione, hay que tener derechos de administrador, y ejecutar PowerShell explícitamente como administrador. Para esto debe hacer clic con el botón secundario en el archivo de programa de PowerShell y seleccionar “Ejecutar como administrador”.

Descargue y descomprima los scripts de la descarga de código de este número. La forma más fácil de ejecutar la aplicación es dentro del ISE. En Windows 7 puede hacer clic en Inicio y escribir ISE. (Observación: Los scripts de PowerShell (que tienen una extensión .psl) no se pueden ejecutar mediante doble clic. La forma más sencilla de ejecutar los scripts de los ejemplos es iniciar el ISE y usar Archivo | Abrir para abrir el archivo.)

Fundamentos de PowerShell

Voy a crear una calculadora del valor actual; la fórmula es muy sencilla, como se puede observar en la Figura 3.

Figura 3 Cálculo del valor actual

En PowerShell las variables comienzan con $. En la línea 7 uso .NET Framework directamente, en la llamada al método estático Pow dentro del espacio de nombres System.Math. El método Pow devuelve un número determinado elevado a un exponente específico. La sintaxis para llamar un método estático de .NET consiste en el nombre de la clase encerrado en corchetes, seguido de dos puntos dobles y el nombre del método: [System.Math]::Pow(2,3). Si ejecuta el ejemplo en el ISE, puede presionar F5 (o hacer clic en el botón Ejecutar) para ver los resultados en panel de resultados. También puede copiar y pegar el código en la consola de línea de comandos; esta ejecutará el script y presentará el resultado.

Esto es un buen punto de partida, pero no se presta bien para reutilizar el script. Podría seguir escribiendo nuevos valores y volver a ejecutar el script cada vez, pero también quiero poder llamarlo desde otros scripts. Agregaré la palabra clave function y convertiré las variables en parámetros para poder variar el resultado y para que el script sea interactivo (ver línea 2 en la Figura 4).

Figura 4 Creación de una función en PowerShell

Adición de la palabra clave function

Le pondré el nombre Get-PresentValue a la función. Al poner nombre a las funciones conviene seguir la convención de PowerShell de usar verbo-sustantivo; esto es un concepto fundamental en el uso y desarrollo de PowerShell. Existen verbos predefinidos tales como Get, Invoke, New y Remove (escriba Get-Verb para ver todo el listado). Escriba Get-Command: esto devuelve todos los cmdlets (y más) definidos en la sesión actual de PowerShell, y es un listado enorme.

Para crear una función basta con escribir function Get-PresentValue {}. A partir de esto creo los parámetros con valores predeterminados y el cuerpo de la función, tal como se puede observar en la Figura 4.

Al comparar la Figura 3 con la Figura 4 se observa que trasladé las variables (tanto los nombres como los valores) a una sola línea y las ubiqué después del nombre de la función, lo que los convierte en parámetros de ésta. Estos parámetros ahora tienen valores predeterminados. No toqué el cálculo del valor. Una de las claves de PowerShell consiste en “escribir menos”. En la línea 3 de la Figura 4 podría haber usado la instrucción return. En este caso su omisión genera el mismo resultado, pero a veces es necesario usar la instrucción return para interrumpir el flujo lógico del programa.

En este ejemplo muestro algunas formas de llamar la función Get-PresentValue. Primero, sin parámetros; todos los parámetros son los predeterminados. Los parámetros se pueden entregar tanto por posición (ver línea 8 en la Figura 4) como por nombre (ver línea 9). Recomiendo que averigüe más sobre los parámetros de PowerShell; PowerShell tiene una máquina poderosa para enlazar los parámetros.

Siguiente paso: cambiar la función Get-PresentValue para que devuelva un objeto .NET en vez de texto simple.

PowerShell se basa en .NET

Una innovación clave de PowerShell es que permite pasar datos completamente tipificados. En la Figura 5 se presenta el concepto de crear un objeto de PowerShell, establecer sus propiedades, devolver el objeto y aprovechar la máquina de PowerShell para imprimirlo.

Figura 5 Devolución de objetos completamente tipificados de las funciones de PowerShell

 En la línea 6 uso el cmdlet New-Object que crea una instancia de un objeto de .NET Framework. Le informo el tipo de objeto que deseo crear (un PSObject), el cual permite tener una vista coherente de cualquier objeto dentro del entorno de PowerShell. En la línea 6 también uso el parámetro –Property que acepta una tabla hash. En PowerShell se emplea la sintaxis abreviada @{} para crear las tablas hash. Los pares clave-valor que se definen en la tabla hash (y se pasan dentro del parámetro –Property) se transforman en propiedades y valores del nuevo PSObject.

En la línea 15, finalmente, llamo la función y los resultados se pueden ver en el panel de resultados (sombreado en azul en el ISE). Observe que PowerShell “sabe” cómo imprimir el objeto. Yo no tengo que emplear ninguna técnica de reflexión para descubrir cuáles son las propiedades que hay que imprimir ni cómo imprimirlas; esta es una de las principales ventajas de PowerShell.

Intervalos y canalizaciones de PowerShell

Luego uso las canalizaciones de PowerShell y presento dos nuevos cmdlets de PowerShell: ForEach-Object y Format-Table (consulte la Figura 6).

Figura 6 Intervalos y canalizaciones de PowerShell

La parte sustanciosa se encuentra en la línea 13; aquí se asoma las naturaleza flexible y composicional de PowerShell. Se definen tres secciones y dos canalizaciones. La primera sección muestra el operador de intervalo (que consiste en dos puntos), la segunda sección consiste en el ForEach y la última sección contiene el Format-Table. Analizaré cada una de ellas.

Primera sección, 1000..10101000..1010 representa una matriz de números enteros del 1.000 al 1.010, inclusive. En este punto PowerShell comenzará a despachar estos valores por la canalización, en cuanto estén disponibles, uno a la vez. Al igual que las shells de Unix o Linux, PowerShell implementa una canalización que permite conectar la salida de un cmdlet con la entrada de otro cmdlet. En el caso de PowerShell la canalización consiste en objetos .NET. Al usar objetos se evita el análisis de texto arbitrario que sale de un comando para extraer los datos, ya que todos los objetos exportan una interfaz coherente (consulte bit.ly/lVJarT).

Segunda sección, ForEach { Get-PresentValue $_ } Esta sección emplea la instrucción ForEach (que también se puede escribir con el alias %), que acepta un scriptblock como parámetro. Los scriptblocks se pueden entender como métodos anónimos (llamados también expresiones lambda en algunos lenguajes de programación). Si desea obtener más información sobre este tema, consulte el libro “PowerShell in Action, Second Edition” por Bruce Payette (Manning Publications, 2011).

 $_ es una variable automática de PowerShell que contiene el valor del objeto actual en la canalización. El resultado final, una matriz de 10 números enteros se pasa a Get-PresentValue, un número a la vez. Como no le pusimos nombre al parámetro, lo paso como el parámetro de posición a $Amount, como se puede observar en el panel de resultados en la Figura 6.

Última sección, Format-Table Format-Table hace lo que su nombre indica, presenta los resultados en forma de tabla. Uso el parámetro –AutoSize, ya que adapta el ancho de las columnas en base al tamaño de los datos.

Observe que no hace falta administrar la iteración sobre la colección, ya que PowerShell “sabe” cómo y qué es lo que debe imprimir acerca del objeto que se está transmitiendo a través de la canalización. Como resultado hay que escribir menos líneas de código, lo que implica menos líneas para depurar. Como el 90 por ciento del tiempo lo dedicamos a depurar y el 10 por ciento a escribir errores, el resultado neto es positivo.

Es hora de la interfaz gráfica: Primera vuelta

Ahora es el momento de usar WPK. El script de la Figura 7 produce la interfaz gráfica de usuario que se puede observar en la Figura 8. Agregué información sobre los tipos a los parámetros de la función Get-PresentValue (ver línea 1 en la Figura 7). Esto permite que otras personas usen esta función para detectar si han proporcionado datos incorrectos, por ejemplo cadenas en vez de números.

Figura 7 New-ListView de WPK

Figura 8 La interfaz gráfica de usuario

Se conservó la esencia del código original de la Figura 6 y se agregó la llamada a Get-PresentValue al parámetro DataContext de ListView, que es un control que proporciona la infraestructura para representar un conjunto de elementos de datos. Las otras piezas de WPK integran el enlace de datos de WPF y configuran la vista en ListView para poder presentar los datos.

WPK sigue el modelo fundamental de PowerShell de usar pares verbo-sustantivo en los nombres de las funciones. Por lo tanto, si quiero crear objetos del tipo Window, Grid, Canvas o ListBox, simplemente agrego el prefijo “New-“ (New-Window, New-Grid, New-Canvas o New-ListBox), y los elementos estarán listos para usar.

Import-Module

Un módulo es un paquete que contiene miembros (tales como cmdlets, scripts, funciones, variables y otras herramientas) que se pueden usar en PowerShell. Una vez que se importa un módulo, sus miembros se pueden usar en la sesión. Tal como se mencionó previamente, WPK es parte de PowerShell Pack, y WPK contiene más de 700 funciones de PowerShell que facilitan la creación por capas de una GUI de WPF sobre PowerShell.

En el contexto de un trasfondo de WPF tradicional, las líneas 17 y 18 en la Figura 7 pueden parecer un poco extrañas. WPK admite el enlace de datos mediante la exposición de dos parámetros: DataContext y DataBinding. Como el parámetro DataContext recibe un scriptblock, aquí paso una línea de código de PowerShell que crea los diez objetos del valor actual de la línea 13 de la Figura 6. A continuación, en la línea 18 configuro la propiedad ItemsSource de ListView con la que se va a enlazar. El parámetro DataBinding acepta una tabla hash (observe el @{}). Las claves corresponden a los nombres de las propiedades del objeto GUI al que desea enlazar.

WPK permite escribir menos código. La función New-GridColumn admite una cadena (por ejemplo Amount, que es el nombre de una propiedad del objeto emitido por la función Get-PresentValue), lo establece como encabezado de la columna (Header) y realiza el enlace de datos en forma automática.

Comencé con una función sencilla, Get-PresentValue y al agregar parámetros para poder volver a utilizarla, emitir un PSObject PowerShell de .NET y aprovechar la canalización de objetos y el operador de intervalo para generar elementos del valor actual terminé con el resultado que se puede observar en la Figura 8. Luego importé el WPK, inserté los objetos de PowerShell en el parámetro DataContext de un control ListView de WPF que enlaza el parámetro ItemsSource y crea la vista ListView con nombres de columnas que coinciden con los nombres de las propiedades de los objetos que se insertan. Al fin tengo una aplicación PowerShell/WPK sencilla para calcular el valor actual. El resultado es satisfactorio, pero está codificado en forma absoluta.

Ahora quiero interactuar con la aplicación para ver qué pasa con mi inversión cuando cambio la cantidad, la tasa de interés y otros parámetros.

Es hora de la interfaz gráfica: Segunda vuelta

Para usar valores diferentes, el script actual de PowerShell/WPK exige que yo cambie los parámetros, guarde el archivo y vuelva a ejecutar el script, lo que es poco ágil.

Lo voy a reestructurar para poder ajustar cinco parámetros desde la interfaz gráfica y para que presente los valores nuevos en ListView.

Función New-Range Antes que nada, quiero agregar una función llamada New-Range (consulte la Figura 9).

Figura 9 La función New-Range

El operador de intervalo de PowerShell no permite variar el tamaño del incremento. En otras palabras, no se puede especificar (1..10 by 2). La función New-Range sí me permite especificar los incrementos, de modo que “New-Range 1 10 2” imprime 1 3 5 7 9.

A continuación daré cuerpo a la interfaz gráfica de WPK para lo cual encapsularé New-ListView dentro de una función New-Window. Al usar solamente New-ListView, WPK se encapsulará dentro de una ventana. New-Window ofrece mucho más control (consulte la Figura 10).

Figura 10 La función New-Window

También levanté el parámetro DataContext de ListView al ámbito de Window y apliqué la nueva función New-Range. Ahora quiero agregar cinco nuevos cuadros de texto, etiquetas y un botón. Esto me permitirá mantener la aplicación en ejecución para poder modificar el resultado de Get-PresentValue. Usaré las funciones New-Grid, New-Label, New-TextBox y New-Button de WPK para crear los controles que necesito. Al usar New-Grid para crear la cuadrícula tengo una mayor flexibilidad para posicionar los controles y al cambiar el tamaño de la ventana.

Para diagramar la interfaz gráfica anidaré cuadrículas dentro de cuadrículas y controles. Todavía estoy usando las funciones New-Range y Get-PresentValue en el parámetro DataContext, como se puede observar en la línea 2 de la Figura 11.

(haga clic para acercar la imagen)

Figura 11 La función New-Grid

También New-ListView sigue ahí, en las líneas 30-37 de la Figura 11. En la línea 30 agregué dos parámetros adicionales –Row y –Column, que indican en qué fila y columna se debe ubicar ListView dentro de New-Grid que se define en la línea 5. La función New-Grid que se define en la línea 5 usa los parámetros Rows y Columns para preparar una cuadrícula. Quiero dos columnas con un ancho de 75 píxeles y tres filas con un alto de 35 píxeles cada una. El asterisco después del segundo valor 75 en el parámetro Rows indica que ocupará todo el espacio disponible.

Ahora ubico cinco pares de etiquetas y cuadros de texto en la ventana, y le indico a los controles en qué cuadrante de la cuadrícula deben anclarse mediante los parámetros Row y Column. También establezco el nombre del cuadro de texto para poder accederlo más adelante, establezco un valor predeterminado mediante el parámetro –Text y especifico el diseño de los controles mediante los parámetros Margin y HorizontalArgument.

Finalmente ubico el botón en la cuadrícula con la función New-Button. Observe que escribo un guion bajo delante de Calculate. Esto me permite usar las la combinación de teclas Alt+C para acceder el botón.

Ahora la calculadora de valor actual ya está casi completa. Sólo me falta conectar el evento del cliente con algún código de PowerShell, leer los valores de los cuadros de texto, pasarlos en forma de parámetros a Get-PresentValue y enlazarlo a ListView.

La función Do-Calculation

Voy a agregar una función Do-Calculation que acepta un solo parámetro, $window (consulte la Figura 12).

Figura 12 La función Do-Calculation

Llamo la función Do-Calculation de la propiedad -On-Click del botón New-Button, el que contiene “_Calculate”.

La implementación de Do-Calculation es trivial. Toma la información de todos los cuadros de texto, los almacena en variables de PowerShell y los pasa en forma de parámetros a las funciones New-Range y Get-PresentValue. Paso el parámetro $window (vea la línea 2 en la Figura 13) que contiene una referencia a New-Window en la Figura 10. Con esto puedo obtener todas las propiedades de la ventana junto con los controles que contiene, en especial los cuadros de texto. Como puse un nombre a cada uno de los controles de cuadro de texto, para canalizar $window a Get-ChildControl puedo pasar el nombre del control y recuperar el texto mediante la propiedad .Text (consulte las líneas 3 a 7 de la Figura 12).

(haga clic para acercar la imagen)

Figura 13 La cuadrícula completa

Después de recopilar toda la información de los cuadros de texto establezco la variable $window.DataContext en el valor del resultado del New-Range que se canaliza a la función Get-PresentValue, lo que genera una matriz de objetos PowerShell que contiene los resultados de los cálculos de PresentValue (consulte las líneas 9 a 12 en la Figura 12).

En la Figura 13 se muestra cómo se puede conectar el evento clic del botón Calculate para llamar la función Do-Calculation y pasar la variable $window (consulte las líneas 28 a 29). Agregué el parámetro –On_Click que admite un ScriptBlock. Dentro de éste llamo la función Do-Calculation, para lo cual paso la variable $window que se crea cuando uso la función New-Window. Cada vez que hago clic en el botón se vuelve a recalcular la pantalla. Observe que también he cambiado la línea 2 en la Figura 13 para llamar también la función Do-Calculation.

Descargue la aplicación terminada en los ejemplos de código fuente que acompañan este artículo para ver el script completo.

Una aplicación WPF sencilla e interactiva

En este artículo presento un script con menos de 75 líneas de código que crea una aplicación WPF estructurada en niveles sobre la plataforma de automatización PowerShell de Microsoft. PowerShell consiste en un lenguaje de scripting más una consola de línea de comandos. Como está integrado profundamente con .NET Framework y Windows ofrece un enorme potencial para la automatización. Por supuesto, esto significa que hay que invertir tiempo en aprender esta nueva plataforma. Pero lo bueno es que resulta muy fácil recoger primero las frutas de las ramas más bajas para volverse más productivo, para sumergirse luego, en el momento que haga falta, a fondo en la gran cantidad de funciones de automatización que proporciona PowerShell, tanto por parte de Microsoft como de la comunidad general de PowerShell.

El modelo de desarrollo ad hoc y el origen de Windows PowerShell

El artículo de Doug Finke es un excelente ejemplo del modelo de desarrollo ad hoc. PowerShell difiere de las otras tecnologías de programación en muchos aspectos: por su énfasis en las abstracciones de alto nivel orientadas en las tareas; su sistema de tipos adaptativo que normaliza los diferentes sistemas de tipos (.NET, Instrumental de administración de Windows [WMI], XML, ADSI, Ado, etc.) y que permite agregar miembros a los tipos e instancias; su máquina de flujo de datos que elimina mucho del código que los programadores deben escribir debido a la discordancia en la impedancia de las diferentes API; su compatibilidad con el modelo de desarrollo ad hoc.

El modelo ad hoc consiste en comenzar a solucionar un problema con técnicas informales. Si se decide que se va a volver a usar, se convierte en un script informal, y si se lo comparte, se formaliza. En nuestra calidad de creadores de herramientas, frecuentemente creamos herramientas para personas con diferentes aptitudes técnicas, y por lo tanto es importante adaptarse a las necesidades y expectativas de todos los destinatarios. Esto muchas veces implica crear una interfaz gráfica de usuario.

El artículo de Doug comienza con un script anónimo para generar el valor actual de cierta cantidad de dinero, con una tasa de interés y un tiempo fijos. Luego lo convierte en una función identificada por un nombre con parámetros con nombres y valores iniciales que devuelve un valor único. Para poder manipularlo con otras herramientas, luego devuelve un objeto. Después crea una interfaz gráfica de usuario sencilla y finalmente una más completa. Sólo invierte tiempo cuando hace falta, y cada script agrega incrementos pequeños al anterior. Al final Doug comparte su script y permite que otras personas usen su herramienta, y también entrega sugerencias acerca de cómo mejorarlo (por ejemplo, en respuesta a una sugerencia asignó tipos a los parámetros para que la herramienta no se indigestara cuando alguien pasaba una cadena). A todos nos beneficia compartir. Yo recibí una herramienta útil y tengo una deuda de gratitud por esto con Doug. Pagué parte de esta deuda al revisar su código y proponer sugerencias. Aunque tengo bastantes conocimientos sobre PowerShell me beneficio de todas las sugerencias que la comunidad me entrega sobre mis scripts. [Snover es el inventor de Windows PowerShell y uno de los principales diseñadores, junto con Bruce Payette y James Truher; consultebit.ly/696Jor. —Ed.]

El modelo de desarrollo ad hoc proviene de la meta de PowerShell de ser una excelente Shell interactiva y un excelente lenguaje de scripting a la vez. Bruce Payette, uno de los diseñadores del lenguaje una vez dijo que la vida útil del 99 por ciento de los scripts de PowerShell comienza en el símbolo del sistema y termina con el retorno de carro. PowerShell es compatible con una gran variedad de estilos de scripting, desde scripts interactivos de una sola línea en un símbolo de sistema a funciones en el estilo de Bash que usan $argumentos a scripts más formales donde los parámetros tienen nombres tipos, se validan, y se decoran con enlace de datos y atributos de ayuda. La razón de seguir este enfoque está en los muchos años de desarrollador Unix, donde escribía incontables scripts para la shell. A medida que las personas usaban mis scripts y solicitaban más características frecuentemente tenía que descartarlos y volver a escribirlos en Tcl o Perl. Frecuentemente terminaba descartando también éstos y reescribiéndolo todo en C. Me parecía demente que aun cuando los diferentes problemas requieren de diferentes grados de formalidad y rendimiento, no existiera una herramienta única que pudiera cubrir un espectro tan amplio de necesidades de scripting. Así las personas podrían invertir en convertirse expertos en esa herramienta, en vez de ser más bien incompetentes en un gran conjunto de herramientas. Tardé bastante tiempo, pero finalmente logré crear la herramienta que puede hacer exactamente eso. Espero que disfrute de PowerShell.

— Jeffrey Snover, Ingeniero distinguido y Arquitecto jefe de Windows Server

Doug Finke*, un MVP en Windows PowerShell, es desarrollador de software en Lab49, una empresa que crea aplicaciones avanzadas para la industria de servicios financieros. Durante los últimos 20 años ha sido desarrollador y autor y ha trabajado con un gran número de tecnologías. Puede ponerse al día en su blog, Desarrollo en un abrir y cerrar de ojos, en dougfinke.com/blog.*

Gracias a los siguientes expertos técnicos por su ayuda en la revisión de este artículo: James Brundage, Sal Mangano, Sivabalan Muthukumar, Marco Shaw, Jeffrey Snover y Sylvain Whissell