PowerShell v1 21 PDF
PowerShell v1 21 PDF
PowerShell v1 21 PDF
1
Indice
PowerShell Comandos .NET
Arranque Funciones WMI
Modos de operación Pipeline COM
Proveedores XML
Registro Expresiones Regulares
A. P. PowerShell v.1 2
Indice
Windows PowerShell (WPS)
Visual Basic Si Si Si
VBA Si Si No*
PowerShell
cmdlets
WPS hace uso de los
recursos de .NET a
Métodos través de los cmdlets,
Librería de Clases ocultando los detalles
Propiedades .NET de programación.
CLR provee:
Compilación
WMI Seguridad CLR COM
Gestión memoria Common Languague Runtime
Excepciones
Windows Management Component Object Model
Instrumentation
.NET Framework
Ejecución
A. P. PowerShell v.1 5
Indice
Arranque de PowerShell
PowerShell requiere que esté instalado .NET Framework 2.0 ó posterior
Verificar su existencia en C:\Windows\Microsoft.NET\Framework\v.2.0.50727 (o versión superior).
El shell es
una simple Clear-host
ventana clear
con un
cls
símbolo >, Recupera última entrada, y anteriores,
donde se
al seguir pulsando flecha arriba. Get-History
entran
comandos Recupera todas las entradas hechas
y presentan Recupera siguiente, y siguientes, Invoke-History
resultados. al seguir pulsando flecha abajo. ejecuta una de las entradas por nº
A. P.
Entrando Start-Process powershell -Verb runAs se entra en modo Administrador.
PowerShell v.1 6
Indice
Graphical Windows PowerShell
Microsoft ofrece a partir de PS v2.0 un interface gráfico para una gestión mejorada de PowerShell
PowerShell v3 tiene 2 componentes: la consola estándar de texto y el entorno integrado ISE.
Panel de scripts arriba,
Ejecutar script
panel consola abajo.
A. P. PowerShell v.1 7
Indice
Perfiles en PowerShell
Al arrancar PS, se cargan automáticamente una serie de ajustes, agrupados en perfiles, que marcan su entorno de uso.
Un perfil en PS es simplemente un script con un nombre especial que reside en una ubicación determinada.
Estos perfiles no se crean de forma predeterminada, ni son obligatorios. Sólo existen si se crean.
$Profile corre automáticamente al arrancar la sesión, y sirve para ejecutar scripts y poner variables al Usuario actual (current user).
El valor de la variable interna $Profile, depende desde donde se llame, pero retorna la vía a Usuario actual, Host actual (PowerShell).
Desde consola PowerShell
Hay 6 tipos de perfiles, reflejados en la tabla. Estos ficheros se cargan en el orden 1,2,3,4, siendo posible redefinir la misma función en diferentes ficheros.
Por defecto $Profile hace referencia a Usuario actual, PowerShell (current user, current host).
$home y $pshome son variables internas. $home guarda el directorio del usuario actual y $pshome guarda el directorio de instalación de PowerShell.
A. P. PowerShell v.1 8
Indice
Crear/editar un perfil
PowerShell soporta 4 tipos de ficheros de perfiles y los ejecuta en un orden predeterminado al arrancar.
La variable interna $Profile contiene la ruta y nombre del fichero que contiene el perfil, que por defecto es de Usuario actual, Host actual.
$Profile Segun desde donde se ejecute, dará la ruta y nombre de un fichero u otro
Desde PowerShell
$Profile tiene 4 propiedades:
-AllUsersAllHosts Desde PowerShell ISE
-AllUsersCurrentHost
-CurrentUserAllHosts
-CurrentUserCurrentHost. True Test-Path $Profile Comprueba si existe el fichero $Profile
Por defecto hace referencia a
Current User, Current Host.
False
Es posible acceder a las otras
Crea nuevo fichero $Profile vacio, si no existía.
propiedades mediante
$PROFILE.CurrentUserAllHosts,
New-Item -path $profile -type file -force Parámetro –force fuerza la creación del fichero.
$PROFILE.AllUsersAllHosts,
$PROFILE.AllUsersCurrentHost.
notepad $profile Abre la aplicación NotePad y abre el fichero que contiene $profile
PowerShell es antes que nada una aplicación de consola que opera básicamente en modo interactivo con el usuario
para gestionar la administración de un ordenador local y/o red de ordenadores, que además ofrece las posibilidades
de automatización que brinda su lenguaje de programación para la elaboración de scripts y operar en modo script.
2 modos de operación
A. P. PowerShell v.1 10
Indice
WPS y sus objetos
En PowerShell todo son objetos
LIBRERIAS
DE CLASES
Clases agrupadas en
namespaces, y éstos
en ensamblados.
Prácticamente todo lo que hay en Windows está representado en una clase WMI.
WMI usa COM para acceder a infraestructura – hard y soft - de sistemas Windows. Adaptador
Es la respuesta de Microsoft al estándar de la industria CIM – Common Information Model. WMI WMI
WPS trata de igual forma a todos los objetos, sean propios WPS, de .NET, WMI, o COM.
A. P. PowerShell v.1 11
Indice
Comandos en WPS
cmdlets Cuando se ejecuta un comando, su salida
vuelve al shell en forma de objetos .NET.
funciones Estos objetos.NET se pueden utilizar
usando sus propiedades y métodos.
WPS tiene 4 tipos de comandos: scripts El cmdlet Get-Member permite examinar
Los comandos son fundamentales las propiedades y métodos del objeto
en cualquier lenguaje. Es lo que se Comandos que sale sale del “pipeline”.
teclea para obtener resultados. Win32 PS C:\> 222 | Get-Member
Nombre comando Parámetro sin argumento Parámetro con argumento Argumento posicional
Hay 2 formas de ver los Los switches son parámetros sin valor, que activan determinada
parámetros de un cmdlet: funcionalidad, p.ej. –recurse.
PS C:\> Nombrecmdlet -?
PS C:\> get-help Nombrecmdlet Se puede calcular el valor de un parámetro,
También con con los operandos entre parántesis.
(get-help Nombrecmdlet).parameters Ejemplos:
El paréntesis pide a WPS que -Get-ChildItem (“c:\” + “temp”) //concatenación de cadenas con +.
genere un objeto, del que pedir -Get-ChildItem ($a + $b) // siendo p.ej. $a = “c:\” y $b = “temp”
una propiedad. -Get-Process -id (120+10)
A. P. PowerShell v.1 12
Indice
Cmdlets
Un cmdlet es una instancia de una clase .NET que corre dentro de un proceso PowerShell.
Un cmdlet es una pieza autocontenida de soft que realiza determinada tarea.
Nombre comando Parámetro sin argumento Parámetro con argumento(s) Argumento posicional
Verbo = acción a realizar. Un parámetro es un bloque que Argumento es un valor asociado El parámetro sale de la
Nombre = objeto afectado. comienza con “-” y controla el al comando. posición en el comando.
comportamiento del comando. Entrecomillar si tiene espacios. No se necesita su nombre.
Parámetros comunes son un conjunto de parámetros que se pueden usar con cualquier cmdlet.
-whatif No se ejecuta el comando, sólo se indica lo que sucedería si se ejecutara
Parámetros comunes
Get-PSDrive
Info datos accesibles
Mismo resultado con:
$a = New-Object System.Random
$n = $a.Next(1,10) > 1400 cmdlets:
Get-xxx
Set-xxx
Add-xxx
Enable-xxx
Get-Command xxx.exe
PowerShell muestra la ruta al ejecutable.
La búsqueda sólo se realiza en
Disable-xxx
New-xxx
PS> vías incluidas en la variable de Remove-xxx
PS> [Tab] entorno %Path%. Write-xxx
PS> [cmdlet] | [cmdlet] Out-xxx
Get-Member PS> [cmdlet] | More
Get-Command Import-xxx
Lista comandos disponibles Export-xxx
Para obtener información sobre métodos y PS> [cmdlet] ; [cmdlet]
propiedades de un objeto: pasar una instancia del Get-Command Invoke-xxx
PS> …….. ` presenta cmdlets en una pantalla Register-xxx
mismo, como resultado de un cmdlet, a través del
PS> # comentario Get-Command write-*
pipeline al cmdlet Get-Member: Select-xxx
cmdlets que empiezan por write-.
Get-PSdrive | Get Member –membertype method Start-xxx
o directamente pasar el objeto al pipeline: Stop-xxx
Info sobre comando(s)
Con un
bloque de
instrucciones
Con una
sentencia de
operación
A. P. PowerShell v.1 15
Cmdlets destacados III Indice
A. P. PowerShell v.1 16
Indice
Cmdlets destacados IV : Get-Help
Get-Help facilita información sobre comandos como sinopsis, descripción, sintaxis, parámetros, ejemplos, notas, etc.
Para recabar ayuda sobre un cmdlet concreto : PS C:\> Get-Help Write-Host –ShowWindow El parámetro
PS C:\> Get-Help Write-Host –ShowWindow
La información se puede dar –Detailed, –Full o -Examples. visualiza la
PS C:\> Get-Help Write-Host –Full información de
PS C:\> Get-Help Write-Host –Detailed ayuda en ventana.
PS C:\> Get-Help Write-Host –Examples
A. P. PowerShell v.1 17
Indice
Los alias
Un alias es la abreviatura de un cmdlet o de un ejecutable, sin parámetros.
Por ejemplo dir es un alias del cmdlet Get-ChildItem. [También los es ls del mundo Unix].
Si una función se usa a menudo, conviene definirla con ámbito Global. Así, la función está disponible no sólo en la consola WPS, sino también para
cualquier script que se ejecute desde la consola. Hay 3 opciones para definir un ámbito (scope) Global:
✓ Manualmente: se define manualmente la función en la consola WPS.
✓ Perfil script: se coloca el código de la función en el perfil script para que cada vez que se abra WPS se cargue automaticamente.
✓ Dot-sourcing: se coloca el código de la función en un script y se invoca con (.).
En dot-sourcing se guarda el código en un script tal como C:\temp\test.ps1. Luego se ejecuta .c:\temp\test.ps1,
y el script corre en ámbito Global, que significa que cualquier variable o función definida en él persistirá todo lo que dure el shell.
A. P. PowerShell v.1 19
Indice
Parámetros de cmdlets y funciones
PowerShell trata a los parámetros de cmdlets de la misma forma que a los parámetros de funciones.
Cmdlet [ –parametro1 –parametro2 arg1,arg2 arg3 ] Function nombre (parámetro1, parámetro2) {...código funcion...}
Todos los cmdlets tienen parámetros, identificados por sus nombres. Function Ver-Raiz ($base) { $raiz= [Math]::Sqrt($base) ; Write $raiz}
En caso de no indicar los nombres, se toma un orden predefinido.
Get-ChildItem C:\temp *.doc # se dan 2 parámetros en su orden predefinido
Dá lo mismo que
Get-ChildItem -Path C:\temp -Filter *.doc # nombres identifican parametros El parámetro(s) puede ir dentro de la llave general, separados por comas, y entre paréntesis.
Las mismas reglas de validación de parámetros son aplicables a los parámetros de cmdlets que a los de funciones.
Actúan como un filtrado que restringe los valores de parámetros entrados. Aplicables también a valores de variables.
Function Ver-Raiz([ValidateRange(0,200)]$base) { .....} #restringe los valores de entrada del parámetro entre 0 ...200.
A. P. PowerShell v.1 20
Indice
Funciones Avanzadas - Advanced Functions
Advanced Functions brindan una forma de escribir funciones propias que se comportan como cmdlets.
#REQUIERE WPS version 2.0 o superior
Function Ver-NombreMayusculas
{ La primera sección, entre <# y #>, contiene información para el cmdlet de ayuda Get-Help.
<#
.Synopsis
Escribe nombre entrado por consola
.Description
Función de prueba de Advanced Functions
.Parameter out
String
.Example
PS> Ver-Nombre “¡Muestra nombre!”
.Link
about_functions
about_functions_advanced
about_functions_advanced_methods
about_functions_advanced_parameters
.Notes
Autor: A.P.
#>
[CmdletBinding()] Ejemplo
Param Lo que distingue a una función avanzada es CmdletBinding, que permite
( la asignación de atributos, si bien en la mayoría de casos se usan sin ellos:
[Parameter(mandatory=$true)]
[ValidateLength(1,10)]
[CmdletBinding()]
[String]$Nombre
)
Se definen los parámetros y atributos que tendrá la función:
Begin { [Parameter(mandatory=$true)] # parámetro obligatorio,
} [ValidateLength(1,10)] #validación : longitudes entre 1 y 10 caracteres.
Process { [String]$Nombre #nombre del parámetro, del tipo string.
Write-Host $Nombre.ToUpper()
} Cada función define 3 métodos que determinan su operatividad:
End { Begin{}: Se llama una sóla vez en cada instancia.
} Process{}: Se llama una vez por cada entrada para su procesamiento.
} End{}: Se llama una sóla vez al terminar.
Esta es la forma de definir una función personalizada
que se comporta como un cmdlet en PowerShell.
A. P. PowerShell v.1 21
Indice
Atributos de parámetros
Los parámetros aceptan atributos que regulan su comportamiento y validan entradas recibidas.
Position = position Posición cuando hay [AllowNull()] Permite recibir valor $null (*)
varios parámetros.
[AllowEmptyString()] Permite recibir cadena vacia (*)
ParameterSetName = name Define el parámetro
como perteneciente a [AllowEmptyCollection()] Permite recibir colección vacia (*)
un conjunto de otros
parámetros [ValidateCount(limite inferior, limite superior)] Restringe nº elementos en colección
relacionados.
[ValidateLength(limite inferior, limite superior)] Restringe longitud de cadena
ValueFromPipeline = $true Admite valor desde entrada para este parámetro
pipeline
[ValidatePattern("regular expression ")] Fuerza que la entrada responda a un
ValueFromPipelineByPropertyName = $true Acepta entrada de patrón especificado
pipeline si propiedad
del objeto coincide [ValidateRange(limite inferior, limite superior)] Restringe a valores mínimo y
con el nombre. máximo una entrada numérica
Acepta todas las [ValidateScript( { script block } )] La entrada debe cumplir la condición
ValueFromRemainingArguments = $true
entradas que no han que aparece en el bloque script.
sido asignadas a La entrada debe coincidir con uno
[ValidateSet(“Op1",”Op2”, ..., “Opn")]
parámetros por de los valores dados
posición o nombre.
Sólo un parámetro [ValidateNotNull()] La entrada no puede ser null.
puede tener este
atributo. [ValidateNotNullOrEmpty()] La entrada no es ni null ni vacia.
Pipeline
cmdlet1 cmdlet2 cmdlet3
2 3 1 3
Al llamar a comandos individuales, se $_ es una variable objeto creada Format-Table presenta columnas de interés.
crea un nuevo pipeline por cada uno. automáticamente por defecto por WPS. Sin -property, igual salida que Out-Default.
Cada comando corre en un pipeline Viene a significar “este objeto”. Format-List, alternativa de presentación.
propio, al ser llamado desde consola. (Arriba, su propiedad .Id se compara con 499). Group-Object agrupa por valores de propiedad(es)
Dentro de un script, los comandos
Select-Object es un modo más genérico Otros comandos útiles con Pipelines:
corren en un unico pipeline.
de obtener propiedades del pipeline. ■ Sort-Object para clasificar
■ Measure-Object para suma, media, max y min.
La salida del pipeline es Out-Default Foreach-Object recorre elementos de
que pasa el objeto a Out-Host para su una colección ejecutando código en {…}
formateado y salida a consola. sobre cada elemento. Nº de comdlets en un pipeline es ilimitado.
Unix y DOS ya tenían pipelines, la salida de un comando a otro era texto, y no objetos .NET, como ahora en WPS
A. P. PowerShell v.1 23
Indice
Cmdlets relacionados con Pipeline
Where-Object filtra objetos cuya Select-Object tras –Property van Sort-Object tras –Property van las
propiedad responde a valores dados. los valores que se desea visualizar. propiedades según las cuales clasificar.
Alias where o el simbolo ?- Alias select.
- Sólo se puede realizar 1 comparación.
Pipeline Pipeline
Measure-Object realiza cálculos sobre la propiedad indicada con los objetos en el pipeline (número, media, suma, máximo, mínimo).
A. P. PowerShell v.1 24
Indice
Pipeline salidas
Los cmdlet no crean salida, sólo ponen objetos en el pipeline. Cmdlets especializados crean las salidas.
cmdlet1 cmdlet2
No se produce salida
Format-Table -property
-property
Format-Wide
A. P. PowerShell v.1 25
Indice
Pipeline - Ramificaciones
El cmdlet Tee-Object permite hacer una ramificación hacia otro depósito de datos, sin dejar de pasar
el objeto al siguiente cmdlet en el pipeline.
Tee-Object pasa el contenido al siguiente cmdlet en el pipeline, y también, en paralelo, a una variable o un fichero.
Pipeline Pipeline
A. P. PowerShell v.1 26
Indice
Proveedores (Providers)
PowerShell ofrece un conjunto coherente de cmdlets para recorrer y navegar
diferentes estructuras de datos – Providers - como el sistema de ficheros, el registro,
las funciones, las variables, Active Directory, o WMI (Windows Management Interface).
Get-PsProvider lista los proveedores de datos - providers - disponibles en WPS.
Provider Datos
Alias Aliases en PowerShell
Certificate Certificados de firmas digitales
Environment Variables de entorno Windows
Los “drives” son estructuras de datos que expone WPS. Un proveedor actúa como un interface entre
Se obtienen con: get-psdrive. PowerShell y la fuente interna de datos.
Cada proveedor - provider - esta asociado a un drive.
Get-PSDrive lista los drives fisicos existente C, D, .., y además las variables
de entorno (env), el registro (HKCU, HKLM), Windows certificate store
(Cert), Alias, variables en Variable y funciones en Function.
A. P. PowerShell v.1 27
Indice
Navegación de datos
WPS tiene un único modelo de navegación en las distintas fuentes de datos (providers).
Las rutas en WPS admiten los siguientes símbolos: Las rutas pueden ser relativas o absolutas.
Las rutas relativas dependen del directorio actual.
■ .\ representa al directorio actual cd .
.\test.txt se refiere al fichero test.txt en directorio acutal.
■ ..\ representan al directorio padre del actual cd .. ..\test.txt se refiere al fichero test.txt en directorio padre.
■ \ representa al directorio raiz cd \ Las rutas absolutas son independientes del directorio actual.
WPS convierte automaticamente las rutas relativas en absolutas.
■ ˜\ representa directorio inicial del “provider” cd ~
Esto mismo se consigue con el cmdlet Resolve-Path.
A. P. PowerShell v.1 28
Indice
Sistema de Ficheros I
Directorios y Ficheros admiten como acciones: crear, borrar, copiar, mover y renombrar.
Los cmdlet Get-ChildItem y Get-Item dan los directorios y ficheros ya existentes a partir de un determinado punto.
Se pueden crear nuevos directorios y ficheros, renombrarlos, llenarlos con contenido, copiarlos, moverlos y borrarlos.
Ficheros
Directorios
¡No hay cmdlet para crear directorios, si para borrarlos, etc!.
dir1 dir2 dir3
Copy-Item C:\temp\dir3 C:\temp\dir4, copia directorio
Move-Item C:\temp\dir3 C:\temp\dir5, mueve directorio
Rename-Item C:\temp\dir5 C:\temp\dir3, renombra directorio
Remove-item C:\temp\dir4, borra directorio con confirmación
Ficheros Remove-item C:\temp\dir4 -recurse, borra directorio sin más.
Mismos cmdlets para manejar directorios y ficheros. - recurse borra directorios sin pedir confirmación de borrado.
A. P. PowerShell v.1 30
Indice
Lectura de ficheros
El cmdlet Get-Content sirve para leer ficheros de texto .
Se usa como parámetro el nombre del fichero a leer.
Líneas leidas se guardan en array $a.
$a = Get-Content C:\temp\test.txt
Get-Content
lee el contenido
Uso de Get-Content y el pipeline para
de un fichero
obtener el nº de líneas, palabras o
línea a línea, y caracteres de fichero
pasa cada
línea de texto
al pipeline,
como objeto.
-encoding Codificación de caracteres utilizada: Unicode, UTF7, UTF8, UTF32, Out-File c:\test.txt -encoding ASCII
ASCII, BigEndianUnicode, Default, o OEM. Por defecto : Unicode.
-append Añade datos al fichero, en lugar de sobreescribir. Out-File c:\ test.txt -append .txt
-width Define máximo nº de caracters en cada línea. Out-File c:\test.txt –width 150 .csv
Si la línea que se escribe, tiene más , se trunca. .xml
Por defecto se usa el ajuste de consola PS. .html
-force Fuerza escritura, por encima de restricciones como sólo lectura, Out-File c:\test.txt -force
pero no modifica permisos de seguridad.
-noClobber Impide que Out-File escriba en fichero existente Out-File c:\test.txt -noClobber
-confirm Pide confirmación antes de continuar Out-File c:\test.txt -confirm
Posibilidades adicionales que brinda el redireccionamiento con “>” y el uso del cmdlet Out-File.
WPS HKLM HKEY_LOCAL_MACHINE Ajustes generales del PC, hard y soft, comunes a todos los usuarios.
El registro está organizado en 5 niveles de claves, similares a carpetas, que guardan otras claves y valores.
Una clave o subclave puede tener ninguno o varios valores, un valor por defecto y ninguna o varias subclaves.
Los valores son análogos a ficheros. Los datos en el registro se guardan dentro de valores.
De las 5 claves del registro, PowerShell dá acceso, por defecto, a 2 de ellas : HKCU y HKLM.
Para acceder a otras claves, habría que declararlas como nuevos proveedores –PSProvider- de PowerShell.
new-psdrive –name hkcr –psprovider registry –root hkey_classes_root
new-psdrive –name hku –psprovider registry –root hkey_users
new-psdrive –name hkcc –psprovider registry –root hkey_current_config
Ahora ya se podría acceder directamente a estas nuevas claves.
A. P. PowerShell v.1 33
Indice
Registro de Windows – General II
El Registro almacena valores de configuración para el sistema operativo, aplicaciones y usuarios.
Windows cuenta con la aplicación regedit.exe Valores : Tipos
en el directorio C:\Windows que sirve para Por defecto como cadenas, tipo REG_SZ, pero pueden ser:
acceder y editar datos del Registro. ■ REG_BINARY: Valores binarios, mostrados en hexadecimal.
Se accede desde Inicio EjecutarRegedit ■ REG_SZ: Secuencia de caracteres o cadena.
■ REG_DWORD: Un único número en hexadecimal o decimal.
Los cambios en el Registro son permanentes. ■ REG_MULTI_SZ: Cadena que puede tener varias líneas.
Verificar cuidadosamente antes de realizarlos. ■ REG_EXPAND_SZ: Texto, para rutas o variables de entorno.
Cada clave o subclave tiene un valor asociado con ella, el cual tiene 3 componentes: nombre, tipo, y datos.
A. P. PowerShell v.1 34
Indice
Acceso al Registro con WPS
PowerShell tiene el proveedor Registro, para acceder y manipular el registro en la máquina local.
Directorios accesibles del Registro: HKEY_LOCAL_MACHINE (HKLM) y HKEY_CURRENT_USER (HKCU).
Estos directorios están representados por 2 objetos PSDrive, llamados HKLM: y HKCU: .
Mismos comandos de navegación para el Registro que para p. ej. el Sistema de Ficheros
Get-ChildItem hklm:\software
Da las subclaves de una clave
Get-Item hklm:\software\Microsoft\PowerShell
Accede a una clave
A. P. PowerShell v.1 35
Indice
Acceso al Registro con WPS
HKEY_CURRENT_USER HKCU – guarda información sobre el usuario actual
HKEY_LOCAL_MACHINE HKLM – guarda ajustes generales del ordenador
A. P. PowerShell v.1 36
Indice
Unidades de datos [drives]
Una unidad – drive - es una ubicación de almacenamiento de datos a la que se puede acceder en PowerShell.
Los Providers de PS crean algunas unidades automáticamente, como las unidades de sistema de archivos (C: y D:),
y las unidades de Registro (HKCU: y HKLM:).
También se crean unidades propias de PS. Estas unidades son muy útiles, pero estan disponibles sólo en PS.
No se puede tener acceso a ellas con otras herramientas de Windows, como el Explorador de Archivos o cmd.exe.
PowerShell usa el término PSDrive en los comandos que funcionan con las unidades de PowerShell.
El cmdlet Get-PSDrive lista las unidades de PowerShell en su sesión de PowerShell.
PowerShell crea nuevos drives con el cmdlet New-PSDrive.
Y no solo drives de red, sino también como fáciles accesos La referencia a la nueva unidad de PowerShell se hace como
a importantes ubicaciones en el sistema de ficheros u otros. con cualquier otra unidad de PowerShell; es decir, por su
New-PSDrive -name cx -PSprovider FileSystem –root c:\temp1 nombre seguido de dos puntos (:). Ej. cx:.
A. P. PowerShell v.1 37
Indice
Entrada de datos
1 Desde la propia consola con read-host.
La salida se coloca en el pipeline [canal].
$n = read-host “Entrar Nombre” se guarda en variable $n.
2 Aceptar
Cancelar
3
La lectura se guarda en variable $a como un array. Desde ficheros
Mediante módulos,
que se guardan con .psm1,
se recorren los scripts.
A. P. PowerShell v.1 38
Salida de datos Indice
La salida de WPS puede ser cualquier objeto .NET cuyo ensamblado esté cargado en PowerShell.
Los datos de salida pueden ser dirigidos a una variable, a un fichero, a otro comando (via pipeline) o a la consola.
Por defecto, son enviados a la consola (host).
2
A ficheros .txt, .csv, .xml, .html
Salida a fichero
[Append]
[, como separador]
Registro de
Windows
A. P. PowerShell v.1 39
Indice
Mas salidas de datos
PowerShell genera salidas de otras formas, que no pasan por el pipeline.
Lo peculiar de estas salidas es que pueden ser suprimidas.
Cada uno de estas salidas alternativas cuenta con una variable de configuración incorporada.
Cuando la variable se pone en Continue, los comandos producen una salida.
Cuando la variable se pone en SilentlyContinue, no se produce ninguna salida.
A. P. PowerShell v.1 40
Formatos de salida Indice
3 son los cmdlets de WPS para el formateado de salidas: Format-List, Format-Table y Format-Wide.
-property Las propiedades que aparecen en la salida se
Format-List pueden obtener mediante
-property
Format-Table Format-Wide Limita la salida a una sola propiedad por objeto.
A. P. PowerShell v.1 41
Indice
PowerShell Script Language – scripts y scriptblocks
Además de los cmdlets, WPS ofrece un lenguaje propio de scripting para crear secuencias de comandos.
El lenguaje incluye variables, arrays, comandos, funciones, bucles, y tratamiento de errores.
Microsoft reconoce la influencia de Unix, PERL, PHP, Python y C# en la creación del lenguaje de WPS.
WPS hace uso de corchetes { }, y punto y coma ; , aunque éstos no se necesitan como separadores de líneas.
Un script - secuencia de comandos - se guarda en un fichero con extensión .ps1, y se ejecuta posteriormente.
La principal diferencia con los comandos del shell es que los scripts se guardan en disco, y por tanto no se borran al abandonar la sesión WPS.
Scriptblocks
PowerShell soporta bloques de scripts que actúan exactamente igual que las funciones sin nombre y los scripts.
$scriptblock1 = { bloque de sentencias }
Como las funciones y los scripts, los bloques se pueden invocar :
- directamente & { “bloque sentencias"}
- Invocando la variable que lo define & $scriptblock1.
A. P. PowerShell v.1 42
Símbolos en PowerShell Indice
Editor de texto:
comandos y
Fichero texto Fichero texto Fichero texto
expresiones,
****.vbs con la sintaxis de ****.ps1 ****.txt
(visual basic script) PowerShell.
Cmdlets Variables
Funciones
Constantes
Operadores
Arrays
xxx.ps1
Bloques código
Hash Tables
Un script WPS se escribe en un editor de texto, y se guarda en fichero con extensión .ps1.
Este fichero .ps1 es el equivalente a ficheros .exe en aplicaciones .NET.
. NET Framework
.NET Framework actúa como un interface entre WPS y el sistema operativo, traduciendo el código a formato ejecutable.
A. P. PowerShell v.1 44
Indice
Estructura de los scripts
[int]$a = 222
Zona declarativa $b = “Pepe”
Definición y asignacion variables
Estructura (recomendable) de los scripts
Se guarda
cmdlets como fichero
xxx.ps1
expresiones
bucles, decisiones
Comandos cmdlets,
expresiones, bucles,
llamada a funciones pipelines
Llamadas función
A. P. PowerShell v.1 45
Indice
“Execution policy” de scripts
Por defecto WPS corre en modo Restricted, que no permite la ejecución de scripts.
Se comprueba la política de ejecución en curso, llamando al cmdlet Get-ExecutionPolicy.
Get-ExecutionPolicy
?
[constraint] $var = "Valor“ Variable restringida a los valores permitidos por la regla de validación.
[validaterange(0,10)][int]$var=7
Set-Variable fix 222 -option Constant Set-Variable Nom1 “Pepe” -option ReadOnly
A. P. PowerShell v.1 49
Indice
Variables internas de WPS
WPS tiene una serie de variables predefinidas, llamadas variables internas o integradas.
Nombre variable Descripción Nombre variable Descripción
$LastExitCode Contiene el código de salida del último $$ Ultimo simbolo en la última linea recibida en el shell
programa Windows ejecutado
$? Estado de última operación. True si se realizó con éxito.
$MyInvocation Información sobre el comando en curso.
$^ Primer símbolo en la última línea recibida en el shell
$NULL Contiene NULL o valor vacio. $_ Objeto actualmente en el pipeline
$args Array para parámetros iniciales de funciones o scripts
$PID Identificador de proceso
$ConsoleFileName Nombre fichero de consola más recientemente exportado
$PSHome Ruta de la instalación de PowerShell $True True
A. P. PowerShell v.1 50
Indice
Tipos de datos
PowerShell es un lenguaje loosely typed* (en contraposición p. ej. a C# que es strongly typed*).
A. P. PowerShell v.1 51
Indice
Números
Los números en PowerShell son instancias de las clases numéricas de .NET.
$x = “Erase " Concatenar PS C:\> -split “Erase una vez" $x = “Erase una vez un chico”
$y = “ una vez.." Erase $y = $x -replace “un chico", “una chica"
$z = $x + $y una $y
$z = Erase una vez.. vez Dividir Erase una vez una chica Reemplazar
“Here-Strings”
Las cadenas here-string se usan para declarar bloques de texto.
$hs = @" # Pueden ser comillas simples. Un “here-string” comienza con @” en la primera línea.
Texto
en varias
líneas
"@ # Pueden ser comillas simples. Un “here-string” termina con “@ en la última línea.
En las "here-string" entre comillas simples, las variables se interpretan literalmente y se reproducen exactamente.
En las "here-string" entre comillas dobles, las variables se reemplazan por sus valores.
A. P. PowerShell v.1 53
Indice
DATA sections
Data sections son una técnica usada en PowerShell para separar la parte de código de la de datos.
Las secciones DATA almacenan cadenas que se usarán en Una segunda forma de seprar código y texto es generar 2 ficheros
algún punto de un script. Puede haber varias secciones distintos, uno para el código (.ps1) y otro para datos(.psd1).
DATA en el mismo script.
Fichero test.ps1
Arriba el fichero con el código, que referencia el fichero de datos test.psd1.
A. P. PowerShell v.1 54
Indice
Fecha y hora
Get-Date crea una instancia de la clase .NET System.DateTime, que contiene la fecha/hora actual.
Para dar sólo la fecha:
Get-Date -displayhint date Para dar sólo la hora:
Get-Date -displayhint time Get-Date también una fecha/hora, asignable a una variable:
$f1 = Get-Date –displayhint time “12/12/2012 12:10:10"
Internalmente WPS procesa periodos de tiempo como instancias de la clase System.TimeSpan. El cmdlet Start-Sleep suspende la
actividad en un script o sesión
$avance = New-TimeSpan -Days 10 -hours 12 -minutes 30 # crea un periodo de tiempo durante un tiempo especificado
en segundos o milisegundos.
$now = Get-Date # obtiene fecha/hora actual
PS C:\> Start-Sleep -s 5
$futuro = $now + $avance # crea nueva fecha/hora Detiene el proceso 5 segundos.
El objeto (Get-Date) permite usar Declarar una $variable = Get-Date A partir de la clase .NET DateTime,
sus métodos y propiedades: permite usar sus métodos y propiedades. usando sus propiedades y métodos.
Propiedades Métodos Propiedades Métodos Propiedades Métodos
-Date -Add -Date -Add -MaxValue -Compare
-Day -AddDays -Day -AddDays -MinValue --DaysinMonth
-DayOfWeek -AddHours -DayOfWeek -AddHours -Now -Equals
-DayOfYear -AddMinutes -DayOfYear -AddMinutes -Today -FromBinary
-Hour -AddMonths -Hour -AddMonths -UtcNow -FromFileTime
-Minute -AddSeconds -Minute -AddSeconds ...
-Month -AddYears -Month -AddYears
-Second -Substract -Second -Substract
-Year ... -Year ...
... ...
A. P. PowerShell v.1 55
Indice
Arrays
Un array en PowerShell es un objeto .NET System.Array.
Un array es una estructura simple de organización de datos en la cual se accede a sus elementos a través de un índice (a partir de 0).
Los elementos del array pueden ser de distinto tipo, salvo que se declare strongly typed.
Se puede crear un array vacio usando @( ). Al ser los arrays objetos, se pueden usar sus métodos
Para crear un array, declarar sus items entre comas, y propiedades de instancia, además de los de clase.
$array1 = 1, 2, “Pepe“ Propiedades Métodos
Una forma alternativa es, tratándolo como una colección:
$array1.Count $array1.Clear()
$array2 = @(1,2,”Pepe”)
$array1.Length $array1.IndexOf()
Un array de todos enteros, se puede definir:
[int[]] $ArrayEnteros = 4,5,6 $array1.IsReadOnly $array1.Insert()
$array1.Remove()
Si el array tiene un solo elemento, anteponer una coma.
$array1.RemoveAt()
$array1 = , 22
$array1.Item()
Se añaden dinamicamente elementos al array, con += :
$array1.ForEach()
$array1 += “Juan“, “Paco”
Añadir un item Añadir una nueva clave/valor a una hash table existente, se usa:
Creada una tabla vacía, se pueden entrar claves y valores. $ht.add(“paco”,28800)
$ht = @{} El método add no asume que la clave es una cadena.
$ht.pepe=28001 Para eliminar un elemento:
$ht.juan = 28028 $ht.remove(“pepe”)
Inicializar una Hash Table con items Recuperar el valor asociado a una clave, hay 2 formas de acceder:
Se puede crear e inicializar una tabla hash: $ht[“pepe”]
$ht = @{pepe=28001; juan=28028} O usando el operador “.” [dot]:
WPS asume que las claves son cadenas, al inicializar. $ht.pepe
ConvertFrom-StringData
El cmdlet ConvertFrom-StringData convierte una cadena o
una here-string de pares de claves/valores en tabla hash.
Se puede usar ConvertFrom-StringData en la sección Data
El cmdlet ConvertFrom-StringData convierte el here-string en tabla hash.
de un script.
Here-strings son especialmente útiles cuando los valoes en
la tabla hast incluyen comillas.
A. P. PowerShell v.1 57
Indice
Operadores
Los operadores en PowerShell son polimórficos, actúan sobre muchos tipos de objetos.
Operador Descripción Ejemplos Resultados Operador Significado
A. P. PowerShell v.1 60
Bucles de decisión if y switch Indice
En WPS el valor True es representado por $True, y el valor False por $False
Condition
= $True ? No
Case 3 Case 4
Si Switch
(expression)
{ { {
{ Case 1 Case 2
sentencias1 sentencias2 sentencias4
sentencias3 default
} } }
}
{ { {
sentencias1 sentencias5 sentencias2
if (condition) {...} elseif (condition {...} else {…} } } }
While Do Do
Condition { Exit Do {
No
= $True ? sentencias setenciass Exit Do
} }
Si
{ Loop While
Exit Do Loop Until
sentencias
} Condition
Condition
=$True ? = $True ?
Loop Si No
No No Si
$a = 1 $a = 1 $a = 1
While ($a –lt 10) {$a;$a++} do {$a; $a++} while ($a -lt 10) do {$a; $a++} until ($a –gt 10)
8
Si
9
{
sentencias … Si
Cada item de la colección
} { se asigna a la variable, y
sentencias … con cada valor se van
} ejecutando las sentencias.
Sentencias Sentencias
condición a ejecutar
a ejecutar
inicial Siguiente
en el bucle Para cada objeto de $collection ejecuta {…}
($i=$i+1)
A. P. PowerShell v.1 63
Indice
Variables de entorno en PowerShell
Las variables de entorno son usadas por aplicaciones y otras utilidades para acceder a ficheros concretos, directorios,
y datos de configuración. Hay variables de entorno para cada usuario y variables del sistema propias del ordenador.
Las variables de entorno son distintas de las variables definidas en PowerShell. Las variables de entorno se
Las variables WPS tienen ámbito PowerShell y desaparecen al finalizar la función o script que las contiene. guardan de forma
Las variables de entorno no desaparecen al finalizar el script o función en que se incorporaron. permanente en el Registro.
Al iniciarse PS, lee el Registro
La variable de entorno PATH controla donde PowerShell busca aplicaciones .exe y scripts para ejecución. para obtener las variables
para la sesión.
PowerShell facilita el acceso a las variables de entorno a través del environment provider: Env:.
PS no actualiza el Registro
Se accede al proveedor Env de igual forma que a otros proveedores, como sistema ficheros, registro, etc. cuando se crea una variable
Get-ChildItem Env: # lista las variables de entorno y sus valores. en el proveedor Env:.
Get-Item Env:Path # visualiza nombre de la variable Path y su valor Las variables en el Registro
se crean/borran de forma
En PowerShell se opera con las variables de entorno usando $Env:. permanente usando clases
$Env:Path # visualiza los valores de la variable de entorno PATH. de .NET.
Añadir un directorio a la variable: Asignar valor a variable entorno Borrar variable entorno Al cambiar una variable de
$Env:Path += ";C:\NuevoDir“ $Env:var1 = 222 $Env:var2 = “” entorno, el cambio afecta
sólo a la sesión de WPS.
Para añadir este directorio al Path cada Para un cambio permanente,
También cambiar variables con: También con:
vez que se inicie WPS, se puede añadir la hay que hacer el cambio en
Set-Item Env:var1 Remove-Item Env:var2 el Registro o bien usar .NET.
línea de comando como una entrada en $Env:var1 = 333
un perfil PowerShell.
Copy-Item Env:var1 Env:var2
Un perfil es un tipo de script usado para
configurar PowerShell cuando arranca.
Remove-Item Env:var1
Listado de variables de entorno que contienen la palabra PATH, ordenados alfabeticamente , y en formato tabla.
Path contiene la
direcciones buscadas
para scripts y
PSModulePath las
buscadas para
módulos.
A. P. PowerShell v.1 64
Invocación de scripts Indice
Los scripts se pueden llamar desde una sesión PowerShell o desde la línea de comandos de cmd.exe.
WPS test arg1 arg2 Ejecuta el primer script de nombre test.ps1 que encuentra en la variable de entorno $ENV:PATH.
PS primero chequea si se trata de un alias, función, cmdlet, script y finalmente de ejecutable.
----------------------------------------------------------------------------------------------------------
.\test.ps1 Si el script está en el directorio de PS, entrar sólo nombre script tras “.\”.
El script no aparece en la variable de entorno
& "C:\temp\test.ps1" [Parámetros] Invocación con “&” cuando hay espacios blanco.
cmd
powershell –command .\test.ps1 powershell –noexit .\test.ps1
-noexit asegura que la ventana PS permanezca al
Si el script está en el mismo directorio que WPS. finalizar el script.
Guardar definiciones de funciones, etc, en fichero con extensión .psm1. El cmdlet get-module –listavailable lista los módulos disponibles.
Asegurar que los comandos sigan la sintaxis
Verbo-Nombre estándar de WPS.
Si un módulo debe ser accesible al usuario actual, colocarlo en el directorio Los módulos no requieren registro.
<My Documents>\WindowsPowerShell\Modules\<module name>. WPS busca módulos en una serie de ubicaciones
Si debe ser accesible a todos los usuarios del sistema, colocarlo en su definidas en la variable de entorno PSModulePath.
propio directorio bajo Program Files, y añadir este directorio a la variable PS C:\> get-content env:psmodulepath
de entorno PSModulePath. Guardar el fichero Moduloxxx.psm1 en directorio Modules,
Si no se desea instalar permanentemente el módulo, guardarlo en una de PSModulePath, en un subdirectorio con mismo nombre.
ubicación que hay que especificar al cargarlo con Import-Module –path. Se puede añadir un módulo de cualquier otra ubicación,
supuesto se conozca su via completa.
Añadir ubicaciones a la variable de entorno PSModulePath,
para que WPS localize automaticamente los módulos.
Cuando se carga un módulo desde un script, el módulo es accesible en la sesión. Una vez WPS encuentra los módulos, están disponibles.
Al salir del script, las funciones del módulo están todavía cargadas. Si un módulo no está ubicado en PSModulePath,
Para evitar interferencias con scripts no operativos, proceder a borrar módulos de hay que llamar al cmdlet Import-Module -path
la sesión en curso con el cmdlet Remove-Module. especificando su ubicación exacta.
A. P. PowerShell v.1 66
Indice
Clases y Objetos - fundamentos
En PowerShell todo son objetos.
Las clases son el elemento de programación más importante dentro de la plataforma .NET, y base de la POO.
Objetos
Propiedades
[p.e. color] Métodos
[p.ej. mover]
Clases de
. NET Framework,
-WMI,
-COM,
Clases definidas o de terceros
por el usuario
Instanciación
A. P. PowerShell v.1 67
Indice
Acceso a .NET Framework
.NET es una estructura de Microsoft diseñada para dar soporte a aplicaciones de todo tipo y a scripts.
Microsoft ha generado una serie de lenguajes de programación alrededor de .NET: Visual Basic, C++, C#, y J#.
Microsoft decidió dar soporte .NET a WPS y a su lenguaje de scripts, dándole así acceso a sus vastos recursos.
.NET Framework actúa como interface entre WPS y el sistema operativo Windows.
.NET Framework tiene 2 componentes clave:
• La libreria de clases .NET en que las clases están organizadas en espacios de nombres (namespaces).
• CLR (common language runtime) que posibilita la ejecución de aplicaciones para .NET (p.ej. escritas en C# o VB).
Al ser cada variable una instancia de una clase .NET, cada variable posee las propiedades y métodos de su clase.
Se accede a ellas con la notación de (. ) tras la variable. Propiedades: $a.propiedad1. Métodos: $a.método1( ).
Al ser cada variable en WPS una instancia de una clase .NET, cada variable posee el método GetType( ), conferido a todos los objetos
.NET por la clase madre de todas las clases, System.Object.
En la mayoría de casos, se desea sólo el nombre de la clase, devuelto por la propiedad Fullname o Name.
Los corchetes [ ] encierran una referencia .NET . Acceso a propiedades Propiedades no-estáticas
Estas referencias pueden ser : Acceso a propiedad no-estática: desde la propia clase, con “.”.
• El nombre completo de una clase : [string], [int32], etc. [NombreClase].NombrePropiedad
• Un type accelerator: [ADSI], [WMI], [Regex], etc.
Acceso a propiedades Propiedades de instancia
Métodos estáticos de clases Propiedades estáticas de clases Métodos estáticos (shared): Acceso a propiedad de instancia: desde un objeto, con “.”.
estáticas: pertenecen a la clase estáticas : pertenecen a la clase de la clase y todas sus instancias. $objeto2.NombrePropiedad
( La clase no tiene objetos). (La clase no tiene objetos). Acceso desde la clase.
Acceso desde la clase. Acceso desde la clase. Propiedades estáticas (shared):
Métodos de instancia: de las Propiedades de instancia: de las
instancias (objetos) de la clase. de la clase y todas sus instancias. instancias (objetos) de la clase.
Acceso desde objetos. Acceso desde la clase. Acceso desde objetos.
A. P. PowerShell v.1 69
Indice
Eventos en PowerShell
PowerShell ha dado cabida a la gestión de eventos, con una serie de cmdlets, y con el siguiente procedimiento base:
según el tipo de objeto generador del evento -> registrar el objeto -> el evento -> y la acción a generar de respuesta.
Cmdlet Descripción Hay varios cmdlet para registrar distintos tipos de
Register-ObjectEvent Registra una subscripcion a evento de objeto .NET. eventos:
Registrar evento Registro
Gestor eventos
Register-EngineEvent,
Register-WmiEvent Registra una subscripción a evento de objeto WMI.
Register-ObjectEvent, y
Register-EngineEvent Registra una subscripción a evento de PowerShell. Register-WmiEvent.
Get-EventSubscriber Lista las subscripciones a eventos en la sesión. Esperar el evento
Register-ObjectEvent tiene una serie de parámetros aparte de los arriba usados, como MessageData, SourceIdentifier, etc.
Register-ObjectEvent permite parámetros posicionales en el mismo orden : objeto / evento /accion.
Register-ObjectEvent $timer Elapsed {$n=$n+1;write-host $n;if($n -gt 9){$timer.stop()}}.
A. P. PowerShell v.1 70
Indice
Uso de eventos de clases .NET en diseño de ventanas gráficas [forms]
Además de métodos y propiedades, las clases .NET cuentan con los eventos como elemento de desarrollo.
Con el cmdlet Get-Member se pueden obtener los Con el cmdlet Get-Member se pueden obtener los
Clase Form eventos, además de métodos y propiedades, Clase Button eventos, además de métodos y propiedades,
de un objeto, p. ej. $form, de una clase .NET. de un objeto, p. ej. del botón $Cerrar, de una clase .NET.
Al entrar código, los métodos, propiedades y eventos del Al entrar código, los métodos, propiedades y eventos del
objeto, aparecen tras introducir el objeto y el punto: $form.. objeto, aparecen tras introducir el objeto y el punto: $Cerrar..
$form.Add_Shown({$TextBox.Select()}) $Cerrar.Add_Click({$form.Close()})
Objeto Respuesta al evento [Event Handler] Objeto Respuesta al evento [Event Handler]
Evento Evento
Lo mismo vale para toda la serie de controles que se usan en formularios como Label, TextBox, CheckBox, etc:
crear una instancia ($objeto), y llamar al método Add_*() con el scriptblock de respuesta entre corchetes{}.
A. P. PowerShell v.1 71
Indice
Cuadros de Diálogo
ShowDialog()
ShowDialog()
Este método presenta una ventana de diálogo modal. La aplicación no continúa hasta que se cierra la ventana de diálogo.
Devuelve un valor de la enumeración DialogResult que puede asignarse a la propiedad DialogResult de botones o del formulario.
Pulsar la tecla X del borde superior derecho del cuadro, devueve DialogResult.Cancel.
Este valor puede usarse para procesar las acciones realizadas en la ventana de diálogo.
Cuando el cuadro de diálogo ya no sea necesario, procede llamar al método Dispose() para cerrarlo definitivamente.
Se crea la ventana
Botón Aceptar.
$Aceptar = New-Object System.Windows.Forms.Button
Con new-object se define objeto.
El cmdlet New-Object tiene especial relevancia ya que
$Aceptar.Location = New-Object System.Drawing.Point(75,220)
$Aceptar.Size = New-Object System.Drawing.Size(75,23) Se definen propiedades del objeto. permite obtener objetos a partir de las clases .NET, de los
$Aceptar.Text = "Aceptar" Se añade el objeto al formulario. cuales usar sus amplia gama de métodos y propiedades para
$form.AcceptButton = $Aceptar
$form.Controls.Add($Aceptar) el diseño de formularios y controles.
Botón Cancelar.
$Cancelar = New-Object System.Windows.Forms.Button Con new-object se define objeto.
$Cancelar.Location = New-Object System.Drawing.Point(250,220)
Se definen propiedades del objeto.
$Cancelar.Size = New-Object System.Drawing.Size(75,23)
$Cancelar.Text = "Cancelar" Se añade el objeto al formulario.
$form.CancelButton = $Cancelar
$form.Controls.Add($Cancelar) Etiqueta
Con new-object se define objeto.
$label = New-Object System.Windows.Forms.Label
Se definen propiedades del objeto.
$label.Location = New-Object System.Drawing.Point(130,100)
$label.Size = New-Object System.Drawing.Size(100,20)
Se añade el objeto al formulario.
$label.Text = "Entrar clave"
$form.Controls.Add($label) TextBox .
Con new-object se define objeto.
$textBox = New-Object System.Windows.Forms.TextBox Se definen propiedades del objeto.
$textBox.Location = New-Object System.Drawing.Point(130,120)
Se añade el objeto al formulario.
$textBox.Size = New-Object System.Drawing.Size(150,20)
$form.Controls.Add($textBox)
Imagen
$Image = [system.drawing.image]::FromFile(“c:\altamira.jpg”) Se crea objeto image de fichero.
$Form.BackgroundImage = $Image Se asigna a la propiedad
$Form.BackgroundImageLayout = "None" BackgroundImage del formulario.
$form.Add_Shown({$textBox.Select()}) Pone el foco sobre el TextBox, en respuesta a evento Al invocar el script aparece la ventana con sus controles.
$Aceptar.DialogResult = [System.Windows.Forms.DialogResult]::OK
$result = $form.ShowDialog() Código de La propiedad DialogResult del botón OKButton (aqui OK),
if ($result -eq [System.Windows.Forms.DialogResult]::OK -and $textBox.text -eq "1234") respuesta a la
{$form.Dispose()} se guarda en variable $result = $form.ShowDialog().
if ($result -eq [System.Windows.Forms.DialogResult]::Cancel )
entrada en TextBox $Aceptar.DialogResult = [System.Windows.Forms.DialogResult]::OK
{$form.Dispose()} y a la actuación El valor de esta variable se usa para las acciones posteriores en a la
do {$textBox.text = "" ; $result = $form.ShowDialog() } sobre los botones pulsación de botones Aceptar o Cancelar o botón de Cierre.
until (($result -eq [System.Windows.Forms.DialogResult]::OK -and $textBox.text -eq "1234") ` Aceptar y Cancelar.
-or $result -eq [System.Windows.Forms.DialogResult]::Cancel )
$form.Dispose()
A. P. Script guardado en fichero C:\temp\form1.ps1 PowerShell v.1 73
Indice
Ensamblados y espacios de nombres (namespace)
Framework es una extensa colección de clases organizada en Espacios de Nombres (Namespaces),
los cuales a su vez se organizan en Ensamblados.
Ensamblado Espacio de nombres
Ensamblado (assembly): es una unidad básica de agrupación de código. Espacio de nombres (namespace) es una unidad lógica de
Los ensamblados contienen módulos, los módulos contienen clases, y las clases tienen agrupación de código.
miembros (métodos, propiedades, eventos). Los espacios de nombres organizan los tipos en ensamblados.
Es la unidad básica de despliegue en .NET y también un contenedor de tipos. No sustituyen a los ensamblados, sino que los complementan.
En general, comprende un fichero .exe si es una aplicación, o .dll si es una librería. Los espacios de nombres son una forma de agrupar nombres
La principal diferencia entre una .exe y una .dll, es que una .exe define un punto de entrada. de clases (tipos) reduciendo la probabilidad de colisiones de
Es una colección de tipos y recursos que conforma una unicad lógica de funcionalidad. nombres. Un espacio de nombres puede contener otros
Todos los tipos residen en ensamblados. El CLR no da soporte a clases fuera de ensamblados. espacios de nombres y tipos (clases).
El ensamblado es la unidad para la cual se solicitan y confieren permisos de seguridad. El nombe completo de un tipo (clase) se forma concatenando
La identidad de un tipo depende del ensamblado donde se define. los espacios de nombres que contienen dicho tipo (clase), lo
Cada ensamblado tiene un nº de versión de 128-bit que se presenta como 4 nº decimales: que evita problemas de colisiones de nombres.
mayor, menor, bloque, revisión (p.ej. 3.3.5.1). Los ensamblados pueden contener múltiples namespaces, los
Los ensamblados son la unidad natural de despliegue. Al arrancar una aplicación, ésta carga cuales a su vez pueden contener otros namespaces y tipos.
los ensamblados necesarios. Un namespace es en definitiva una forma lógica de organizar
Cada ensamblado contiene un manifiesto : conjunto de metadatos sobre dicho ensamblado. clases y otros tipos de una simple estructura jerárquica.
Los ensamblados pueden ser private o shared. Por defecto son private y las clases contenidas Los namespaces son transparentes en runtime.
en ellos son sólo accesibles a las aplicaciones en el mismo directorios que el ensamblado.
Pero todos los ordenadores con el .NET instalado, disponen de GAC (global assembly cache)
donde se alojan ensamblados que pueden compartir múltiples aplicaciones.
System
Windows
Forms La primera parte del nombre completo, hasta el último punto a la derecha, es el namespace.
La última parte, desde el último punto, es el nombre del tipo (clase).
Button
Por ejemplo: System.Windows.Forms.Button representa el tipo (clase) Button, que pertenece
al namespace System.Wndows.Forms.
A. P. PowerShell v.1 74
Indice
Ensamblados .NET
Framework es una extensa colección de clases organizada en Espacios de Nombres (Namespaces),
los cuales a su vez se organizan en Ensamblados.
Los ensamblados contienen módulos, los módulos contienen clases, y las clases tienen miembros (métodos, propiedades, eventos).
Buscar las clases disponibles comienza por localizar los ensamblados disponibles cargados donde se alojan las clases.
La clase AppDomain se usa para encontrar los ensamblados cargados.
Su método estático CurrentDomain() dá acceso a .NET donde el método dinámico GetAssemblies() obtiene la lista buscada.
Ensamblados
Añade algún ensamblado que pudiera faltar.
[contenedores de tipos]
Se puede cargar un ensamblado *.dll completo con
$Assembly = [System.Reflection.Assembly]::LoadFrom("C:\folder\file.dll")
Espacios de nombres
System Es la raiz de los tipos fundamentales de .NET Framework.
Incluye clases que se usan en todas las aplicaciones.
En un namespace se pueden definir clases, módulos, interfaces, delegados, enumeraciones, estructuras y otros namespaces,
pero no métodos, propiedades, variables o eventos, que deben declararse en contenedores como clases, módulos o estructuras.
A. P. PowerShell v.1 76
Indice
Algunas clases .NET
Clase Descripción
System.DateTime Instante actual en fecha y hora
Para encontrar los tipos que contiene un ensamblado, se usa
el método GetExportedTypes() de los ensamblados.
System.Math Constantes y métodos matemáticos
System.Random Generador números aleatorios
System.Convert Convierte un tipo de dato a otro
System.Console Entrada, salida y salida de error estándar
System.Diagnostics.Pocess Acceso a procesos locales y remotos
System.Diagnostics.EventLog Interacciona con Windows EventLog
Como un ensamblado puede tener muchas clases, se ha hecho una
System.Diagnostics.Stopwatch Métodos para medir lapsos de tiempo búsqueda con la palabra clave “Button”, limitada a las 5 primeras.
System.Media.Sound.Player Reproduce sonidos de ficheros .wav
El método GetConstructors() de que disponen todas las clases, El método GetConstructors() de que disponen todas las clases,
dá los métodos disponibles en la clase. dá los métodos disponibles en la clase.
A. P. PowerShell v.1 78
Indice
WMI – Windows Management Instrumentation
WMI es un interface de adquisición de datos del ordenador: aplicaciones, hardware, software, y servicios.
WMI se basa en COM, el modelo de objetos predecesor de .NET, y se instala automaticamente con Windows.
WMI es la adaptación de Microsoft al estándar del sector CIM – Common Information Model*.
Lectura de datos básicos del ordenador local Lectura del sistema operativo del ordenador local
Lectura de discos del ordenador local Lectura del procesador del ordenador local
A. P. PowerShell v.1 80
Indice
WMI – Windows Management Instrumentation
El cmdlet Get-WmiObject explora clases y namespaces WMI.
Se accede a los métodos de propiedades de las clases WMI de igual manera que se accede a los miembros de clases .NET.
Almacén WMI
Get-WmiObject –class Win32_diskdrive ordenador local
Presenta todas las instancias de la clase. Se puede omitir –class.
namespaces
Lista todas las clases del namespace que empiezan por Win32_disk
root\default
root\wmi
root\snmp
Get-WmiObject –list –namespace root\wmi
Lista todas las clases del namespace (root\wmi)
El almacén es la base de datos de instancias WMI.
Las instancias de las clases almacenadas se
Acceso a propiedades recuperan dinámicamente por medio de un
provider* al ser requerido por un consumidor
$s =Get-WmiObject Win32_diskdrive tal como un cmdlet de PowerShell.
$s.size El almacén se organiza en namespaces.
Asignando una variable al objeto y llamando a la propiedad buscada
Almacén WMI
Get-WmiObject Win32_diskdrive | select –property size
Seleccionando a través del pipeline la propiedad buscada
ordenador Toshiba
root\cimv2
namespaces
root\default
Get-WmiObject –list Win32_disk* -computername Toshiba root\wmi
root\snmp
COM es la tecnología predecesora de .NET para la gestión de Windows y base de OLE* de Windows.
No hay que cargar los componentes COM (no se llaman ensamblados) porque la infraestructura COM carga automaticamente las DLL
adecuadas según los datos guardados en el registro cuando se instaló el componente.
Algunas clases COM
El acceso a objetos COM, es igual que a objetos .NET, con 2 excepciones: Clase COM Descripción
■ Los objetos COM no tienen constructores con parámetros.
Excel.Application Interacción con aplicación Excel
■ Los objetos COM no tienen miembros estáticos.
Excel.Sheet Interacción con hojas Excel
PowerPoint.Application Interacción con PowerPoint
Scripting.FileSystemObject Interactúa con sistema ficheros
Shell.Aplication Acceso a aspectos de la aplicación
Explorer Shell, tales como
La tecnología COM ha sido y está siendo sustituida por la tecnología .NET, ventanas, ficheros y directorios y
sesión en curso.
siendo por tanto preferible usar .NET en todo lo posible, en lugar de COM.
Un caso en que puede ser necesario recurrir a COM en PowerShell es Shell.LocalMachine Acceso a info sobre máquina
cuando se desea interactuar con aplicaciones de Microsoft Office. actual relativa a Windows Shell.
Shell.User Acceso a aspectos del usuario.
Word.Application Interactúa con aplicación Word
Word.Document Interactúa con documento Word
WScript.Network Acceso al entorno de red
Windows: impresoras, discos de
red, información de dominio.
$WshShell = new-object -comobject “wscript.shell” WScript.Shell Acceso a aspecto de Windows
$WshShell.run(“calc.exe”) # llama a la calculadora de Windows Shell: aplicaciones, alias, variables
de entorno, registo, entorno
operativo.
$WshShell = new-object -comobject “wscript.shell”
$WshShell.Popup(“Entrar código”,9,” Ventana”) Get-Childitem REGISTRY::HKEY_CLASSES_ROOT\CLSID `
# presenta ventana emergente al usuario. -include PROGID -recurse |foreach {$_.GetValue("")}
A. P. PowerShell v.1 Lista todas las clases públicas de todos los componentes COM instalados. 82
COM - Component Object Model Indice
COM es la tecnología predecesora de .NET para la gestión de Windows y base de OLE* de Windows.
PowerShell dispone de un adaptador para COM que hace parecer los objetos COM “casi” como objetos .NET.
Un caso en que se hace necesario recurrir a COM en PowerShell es cuando se desea interactuar con las conocidas aplicaciones de Microsoft Office.
Objetos COM se instancian con New-Object y con el parámetro -comobject seguido del nombre (ProgID) de la clase.
Para Excel, el ProgID es Excel.Application, para Word es Word.Application, y así para el resto de aplicaciones de Microsoft Office.
La clase COM tiene que estar listada en el registro del sistema local. La infraestructura COM carga automaticamente las DLL adecuadas .
Objetos Excel Objetos Word
$Ex = new-object -comobject Excel.Application $W = new-object -comobject Word.Application
$Ex.Visible = $true $w.visible= $true
$b = $Ex.Workbooks.Open(“C:\Libro1.xlsx”) # abre libro dado $h = $W.Documents.Open(“c:\w1.docx”) # abre doc dado
Operaciones dentro hoja cálculo ... Operaciones dentro de documento Word ...
$b.SaveAs(“C:\Libro2.xlsx") # en nuevo fichero, no sobreescribir $h.SaveAs(“c:\w2.docx”) # en nuevo fichero, no sobreescribi
Siempre se puede usar get-member para ver los métodos y propiedades de objetos COM.
* Object Linking and Embedding (OLE), "incrustación y enlazado de objetos“ usada en Office .
A. P. PowerShell v.1 83
Indice
XML
XML se usa para todo, desde ficheros de configuración, hasta ficheros log, o bases de datos.
PowerShell soporta XML como un tipo primitivo de datos.
Elemento: entre
Elemento Agenda Raiz
Atributo
Atributos: son
marcadores < ...>. informaciones
Un elemento adicionales de un
Persona $Mixml=[xml] “<Agenda> Persona
puede contener nodo individual.
Clase = “Personal” <Persona Clase="Personal"> Clase = “Trabajo” Se compone de un
texto u otros
elementos <Nombre>Pepe</Nombre> nombre, el signo
subordinados. <Apellido>Rodriguez</Apellido> “=“ y un valor
Nombre </Persona> Nombre entrecomillado.
Pepe <Persona Clase=“Trabajo"> Juan
<Nombre>Juanl</Nombre>
Apellido <Apellido>Gómez</Apellido> Nombre
Rodriguez </Persona> Gómez
</Agenda>”
Si se desea añadir el nuevo elemento en una ubicación concreta, Con dirección relativa
se usa InsertAfter en lugar de AppendChild
A. P. PowerShell v.1 85
Indice
Importar – Exportar ficheros XML
WPS permite guardar datos de objetos en fichero XML, usando el cmdlet Export-Clixml.
Get-ChildItem c:\temp | Export-Clixml C:\temp\Textxml.xml
Get-ChildItem genera la lista de ficheros del directorio C:\temp, y guarda el resultado en Textxml.xml.
pipeline
C:\temp C:\temp\Textxml.xml
Get-ChildItem C:\temp Export-Clixml
Ejemplo generador
objetos para Export
Export-CliXML exporta objetos a fichero XML.
WPS dispone del cmdlet Import-Clixml que recupera datos XML, usables de nuevo por WPS.
$varxml = Import-Clixml C:\temp\Textxml.xml
Variable WPS
Import-CliXML importa ficheros XML a objetos.
A. P. PowerShell v.1 86
Indice
Expresiones Regulares
Regular expression -RegEx- es una cadena codificada que define un patrón de búsqueda en otra.
Las expresiones regulares en WPS usan los métodos y propiedeades de la clase Regex de .NET.
Las expresiones regulares facilitan la búsqueda y reemplazo de cadenas de caracteres.
Por defecto, las expresiones regulares son case sensitive.
Carácter Descripción
\ Marca el siguiente carácter como un carácter especial o un literal. Para “escapar” caracteres especiales en regex.
^ Iguala el comienzo del patrón.
$ Iguala el final del patrón.
* Iguala caracter precedente cero o más veces.
+ Iguala el caracter precedente una o más veces.
? Iguala el carácter precedente cero o una vez.
. Iguala cualquier caracter simple excepto el caracter de nueva línea.
(pattern) Iguala pattern y recuerda la igualdad. La subcadena igualada se puede recuperar de la colección Matches resultante
usando Item [0]...[n] . Para igualar los caracteres de paréntesis, precederlos con barra inclinada “ \“.
(?:pattern) Iguala pattern pero no captura la igualdad, es decir no se guarda la igualdad para posible uso futuro. Esto resulta útil para
combinar partes de un patrón con el carácter “or” (|). P. ej. “anomal(?: y|ies)” es más corto que “anomaly|anomalies” .
(?=pattern) Búsqueda positiva hacia adelante iguala la cadena en cualquier punto donde se inicie una coincidencia con el patrón.
P.ej. “ Windows (?=95|98|NT| 2000|XP|Vista) ” iguala “Windows” en “Windows Vista” pero no “Windows” en “Windows 3.1”.
(?!pattern) Búsqueda negativa hacia adelante iguala la cadena en cualquier punto donde se inicie una no coincidencia con el patrón.
P.ej. “ Windows (?!95|98|NT|2000|XP|Vista) ” iguala “Windows” en “Windows 3.1” pero no “Windows” en “Windows Vista”.
x|y Iguala x ó y.
{n} Iguala exactamente n veces ( n debe ser siempre un entero no negativo).
{n,} Iguala al menos n veces ( n tiene que ser número no-negativo. Observar la coma al final.
{n,m} Iguala un mínimo de n y máximo de m veces ( m y n tienen que ser enteros no-negativos).
[xyz] Iguala a cualquier de los caracteres contenidos ( xyz es un juego de caracteres).
[^xyz] Iguala cualquier carácter no incluido ( ^xyz es un juego negativo de caracteres).
[a-z] Iguala cualquier carácter en el rango especificado ( a-z es un rango de caracteres).
[m-z] Iguala cualquier caracter no contenido en el rango especificado ( ^m-z es un rango negativo de caracteres).
\b Iguala el límite de una palabra, es decir la posición entre una palabra y un espacio.
\B Iguala un límite sin palabra.
\d Iguala un caracter numérico. Equivalente a [0-9] .
\D Iguala un caracter no numérico. Equivalente a [^0-9] .
A. P. PowerShell v.1 88
Indice
Expresiones Regulares – caracteres especiales II
La verdadera potencia de las expresiones regulares no proviene de la búsqueda de literales, sino del uso de caracteres especiales.
Carácter Descripción
\f Iguala un carácter de salto de página.
\n Iguala un carácter de salto de línea.
\r Iguala un carácter de retorno de carro.
\s Iguala cualquier espacio blanco incluyendo espacio, tab, salto página, etc. Equivalente a “[\f \n \r \t \v ]” .
\S Iguala cualquier espacio no blanco. Equivalente a [^\f \n \r \t\v]” .
\t Iguala un carácter tab .
\v Iguala un carácter tab vertical.
\w Iguala cualquier carácter de palabra incluyendo subrayado. Equivalente a “[A-Za-z0-9_]” .
\W Iguala cualquier carácter no de palabra. Equivalente a “[^A-Za-z0-9\_]” .
\. Iguala .
\| Iguala |
\{ Iguala {
\} Iguala }
\\ Iguala \
\[ Iguala [
\] Iguala ]
\( Iguala (
\) Iguala )
$ num Iguala num , donde num es un entero positivo.
\n Iguala n, donde n es un valor octal de escape, que tienen que ser de 1, 2, o 3 dígitos de longitud.
\uxxxx Iguala el carácter ASCII expresado por el UNICODE xxxx.
\xn Iguala n, donde n es un valor hexadecimal de escape, que tiene que ser de 2 dígitos de longitud.
A. P. PowerShell v.1 89
Indice
Programación de Tareas en PowerShell
PowerShell dispone de cmdlets para la programación de tareas, sin recurrir a Windows Task Scheduler.
La mayoria try
de cmdlets { Código a ser examinado. Si se detecta error se
Ignore No presenta error y no añade a $error.
permiten pasa a sentencia catch correspondiente al error }
SilentlyContinue No presenta error, pero si añade a $error. catch [Error 1]
configurar
esto en su Stop Trata no-terminales como terminales. { Código de respuesta a Error1 detectado en try}
parámetro Continue Muestra y añade a $error, pero continua. Por defecto. catch
-ErrorAction. Inquire Solicita como se debe tratar el error. { Respuesta a resto de errores detectados en try}
finally
{ Código a ejecutar tanto si actúa catch como si no }
El parámetro
-ErrorVariable
asigna el error Para notificar al usuario, se usan los cmdlets: Trap [Error1] {
a la varialbe - Write-Warning para notificar una mera ADVERTENCIA Código a ejecutar
especificada, Return [valor] | Continue | Break }
sin afectar a
- Write-Error para notificar un error superable
$error.
máquina
categoría
Instancia categoría
contador
El contador (counter) es el elemento que recoge los
datos de rendimiento. Los contadores se guardan
máquina por su nombre en el registro.
categoría Hay contadores para el tiempo de ocupación del
procesador, uso de memoria, etc.
Instancia categoría Los contadores se identifican con 4 elementos:
contador máquina, categoría, instancia de la categoría, y
nombre del contador.
Para leer de un contador, hay que crear un objeto de la máquina WMI provee clases para el rendimiento a través
clase PerformanceCounter , usar sus propiedades categoría del provider WMI Performance Counter.
CategoryName, CounterName, y opcionalmente, Las clases comienzan con Win32_PerfRawData.
InstanceName o MachineName , y luego llamar a su Instancia categoría
método NextValue() para hacer una lectura del contador. contador
A. P. PowerShell v.1 93
Indice
Acceso remoto – Introducción I
El objetivo del acceso remoto es ejecutar comando(s) en ordenador(es) remoto(s).
La funcionalidad remota de PowerShell, a partir de PS 2., permite ejecutar comandos PowerShell en equipos remotos en redes Windows.
Tipo de red ?
Aunque de apariencia simple, conseguir una conexión remota En su caso, consultar las ayudas de PowerShell sobre el tema:
resulta dificil en la práctica por diferencias entre versiones,
configuraciones, etc, dependiendo fuertemente de cada caso.
El acceso remoto es un tema particularmente complejo.
! - get-help about_remote
- get-help about_remote_requirements
- get-help about_remote_troubleshooting
A. P. PowerShell v.1 94
Acceso remoto – Introducción II Indice
Una de las más importantes características de WPS es su capacidad de gestión remota de ordenadores en red.
PowerShell usa WinRM (Windows Remote Management), basado en el protocolo WS-Management de Microsoft.
PowerShell como Administrador PowerShell como Administrador
Este cmdlet inicia el servicio WinRM, y lo configura para arranque automático,
y crea un firewall que permite conexiones entrantes.
Enable-PSRemoting –force El parámetro –force evita confirmaciones intermedias. Enable-PSRemoting –force
Se desactiva en cualquier momento con Disable-PSRemoting.
Public Red Private ? La red formada debe ser declarada Private, no Public, para operar de este modo. Red Private ? Public
Set-Item wsman:\localhost\client\trustedhosts elisa Ambos tienen que ser miembros Set-Item wsman:\localhost\client\trustedhosts lenovo
del mismo dominio de confianza.
LOCAL REMOTO
“Lenovo” “Elisa”
Una de las más importantes características de WPS es su capacidad de gestión remota de ordenadores en red.
PowerShell usa WinRM (Windows Remote Management), basado en el protocolo WS-Management de Microsoft.
LOCAL
Red en mismo dominio REMOTO
“Lenovo” Un dominio de Internet es una red de identificación asociada “Elisa”
a un grupo de dispositivos o equipos conectados a Internet.
PowerShell PowerShell
Un dominio se define por una dirección IP común o un
v2 o v3 o v2 o v3 o
conjunto de direcciones IP similares.
superior superior
Un nombre de dominio tal como www.undominio.es
> Windows XP se compone, tras www, de dos partes: el nombre de la > Windows XP
organización y el tipo de organización (p.ej. es, com, etc).
Obtener el contenido de una página web es muy sencillo, contando con la clase System.Net.WebClient.
Ejemplo con una página web de inicio de Yahoo:
PS> $client = New-Object System.Net.WebClient
PS> $client.DownloadString("http://www.elpais.com")
Sólo se necesitan 2 líneas.
La primera crea una instancia de la clase System.Net.WebClient .
La segunda usa el método DownloadString de la instancia recién creada para conseguir la página como una cadena.
La cadena (string) obtenida es el código HTML de la página web, y cuenta con propiedades para manipular la cadena, como
-length
-contains
-equals
-insert
-remove
-replace
-split
- ..
A. P. PowerShell v.1 97
Indice
Reflexión [Reflection]
En el entorno .NET, la reflexión es el proceso de obtener datos de tipos en tiempo de ejecución.
Mediante reflexión se pueden obtener por programa los tipos contenidos en un ensamblado, incluyendo métodos, propiedades, y eventos.
También se pueden obtener otros detalles relacionados: información de espacio de nombres, datos de manifiesto, etc.
Las clases del namespace System.Reflection, junto con System.Type, obtienen información sobre los ensamblados cargados y sus tipos.
También se puede usar la reflexión para crear instancias de tipos en tiempo de ejecución, llamarlas y para acceder a ellas.
Desde PowerShell se puede aprovechar la funcionalidad de .NET Framework para trabajar con la reflexión (reflection).
La reflexión permite inspeccionar ensamblados, tanto .dll como .exe, y examinar sus metadatos.
Los ensamblados contienen módulos, los módulos contienen clases, y las clases tienen miembros (métodos, propiedades, eventos).
La reflexión permite inspeccionar esta jerarquía de ensamblados, módulos, clases y miembros.
El cmdlet Get-Member de PS, al estar PowerShell basado en .NET Framework, dispone de esta función de reflexión.
Este cmdlet analiza un objeto o colección que se le pasa por el pipeline, presentado sus métodos y propiedades.
PS C:\> $a = “hola”
PS C:\> $a | get-member –membertype methods para obtener los métodos de objeto(s).
PS C:\> $a | get-member –membertype properties para obtener propiedades de objeto(s).
La alternativa, usando puramente .NET, consiste en el uso del método GetType(), aplicable a todos los objetos .NET.
El método GetType() retorna un objeto Type (exactamente RuntimeType) que dispone de muchos métodos y propiedades. Una instancia de Type
Type es la base de la funcionalidad de reflexión y es forma más rápida de acceder a datos de ensamblados y clases. puede representar a
cualquiera de los
siguientes tipos:
-Clases
-Tipos de valor
-Arrays
-Interfaces
-Enumeraciones
-Delegados
-Tipos genéricos
Además de leer el ensamblado, namespace, y nombre, el objeto Type que representa a estos objetos tiene métodos, propiedades, etc
A. P. PowerShell v.1 98
Reflexión [Reflection] Indice
Namespace
System.Reflection
dan como respuesta una matriz
GetField() GetFields() FieldInfo[] , MethodInfo[] , PropertyInfo[], FieldInfo
EventInfo[], y ConstructorInfo[] respectivamente.
Métodos relevantes