about_Methods
Descripción breve
Describe cómo usar métodos para realizar acciones en objetos de PowerShell.
Descripción larga
PowerShell usa objetos para representar los elementos de los almacenes de datos o el estado del equipo. Por ejemplo, los objetos FileInfo representan los archivos de las unidades del sistema de archivos y los objetos ProcessInfo representan los procesos del equipo.
Los objetos tienen propiedades, que almacenan datos sobre el objeto y métodos que permiten cambiar el objeto.
Un "método" es un conjunto de instrucciones que especifican una acción que puede realizar en el objeto . Por ejemplo, el FileInfo objeto incluye el CopyTo método que copia el archivo que representa el FileInfo objeto.
Para obtener los métodos de cualquier objeto, use el Get-Member cmdlet . Utilice su propiedad MemberType con un valor de "Method". El comando siguiente obtiene los métodos de los objetos de proceso.
Get-Process | Get-Member -MemberType Method
TypeName: System.Diagnostics.Process
Name MemberType Definition
---- ---------- ----------
BeginErrorReadLine Method System.Void BeginErrorReadLine()
BeginOutputReadLine Method System.Void BeginOutputReadLine()
...
Kill Method System.Void Kill()
Refresh Method System.Void Refresh()
Start Method bool Start()
ToString Method string ToString()
WaitForExit Method bool WaitForExit(int milliseconds), ...
WaitForInputIdle Method bool WaitForInputIdle(int millisecon...
Para realizar o "invocar" un método de un objeto, escriba un punto (.), el nombre del método y un conjunto de paréntesis "()". Si el método tiene argumentos, coloque los valores del argumento entre paréntesis. Los paréntesis son necesarios para cada llamada de método, incluso cuando no hay argumentos. Si el método toma varios argumentos, deben estar separados por comas.
Por ejemplo, el siguiente comando invoca el método Kill de procesos para finalizar el proceso del Bloc de notas en el equipo.
$notepad = Get-Process notepad
$notepad.Kill()
Este ejemplo se puede acortar combinando las instrucciones anteriores.
(Get-Process Notepad).Kill()
El Get-Process comando se incluye entre paréntesis para asegurarse de que se ejecuta antes de invocar el método Kill. A Kill continuación, se invoca el método en el objeto devuelto Process .
Otro método muy útil es el Replace método de cadenas. El Replace método reemplaza el texto dentro de una cadena. En el ejemplo siguiente, el punto (.) se puede colocar inmediatamente después de la comilla final de la cadena.
'this is rocket science'.Replace('rocket', 'rock')
this is rock science
Como se muestra en los ejemplos anteriores, puede invocar un método en un objeto que se obtiene mediante un comando, un objeto de una variable o cualquier cosa que tenga como resultado un objeto (como una cadena entre comillas).
A partir de PowerShell 4.0, se admite la invocación de método mediante nombres de método dinámico.
Obtener información sobre los métodos
Para buscar definiciones de los métodos de un objeto, vaya al tema de ayuda para el tipo de objeto y busque su página de métodos. Por ejemplo, en la página siguiente se describen los métodos de los objetos de proceso System.Diagnostics.Process.
Para determinar los argumentos de un método, revise la definición del método, que es similar al diagrama de sintaxis de un cmdlet de PowerShell.
Una definición de método puede tener una o varias firmas de método, que son como los conjuntos de parámetros de los cmdlets de PowerShell. Las firmas muestran todos los formatos válidos de los comandos para invocar el método .
Por ejemplo, el CopyTo método de la FileInfo clase contiene las dos firmas de método siguientes:
CopyTo(String destFileName)
CopyTo(String destFileName, Boolean overwrite)
La primera firma de método toma el nombre del archivo de destino (y una ruta de acceso). En el ejemplo siguiente se usa el primer CopyTo método para copiar el Final.txt archivo en el C:\Bin directorio.
(Get-ChildItem c:\final.txt).CopyTo("c:\bin\final.txt")
Nota:
A diferencia del modo de argumento de PowerShell, los métodos de objeto se ejecutan en modo de expresión, que es un paso a través de .NET Framework en el que se basa PowerShell. En el modo de expresión no se permiten argumentos bareword (cadenas sin comillas). Puede ver esta diferencia al usar la ruta de acceso como parámetro, frente a la ruta de acceso como argumento. Puede obtener más información sobre los modos de análisis en about_Parsing
La segunda firma de método toma un nombre de archivo de destino y un valor booleano que determina si el archivo de destino debe sobrescribirse, si ya existe.
En el ejemplo siguiente se usa el segundo CopyTo método para copiar el Final.txt archivo en el C:\Bin directorio y para sobrescribir los archivos existentes.
(Get-ChildItem c:\final.txt).CopyTo("c:\bin\final.txt", $true)
Enumeración de acceso a miembros
A partir de PowerShell 3.0, cuando se usa el operador de acceso a miembros (.) para tener acceso a un método que no existe en una colección de listas, PowerShell enumera automáticamente los elementos de la colección e invoca el método en cada elemento. Para obtener más información, consulte about_Member-Access_Enumeration.
Ejemplos
En el ejemplo siguiente se ejecuta el método Kill de objetos de proceso individuales en una colección de objetos .
El primer comando inicia tres instancias del proceso del Bloc de notas. Get-Process obtiene las tres instancias del proceso del Bloc de notas y las guarda en la $p variable .
Notepad; Notepad; Notepad
$p = Get-Process Notepad
$p.Count
3
El siguiente comando ejecuta el método Kill en los tres procesos de la $p variable . Este comando funciona aunque una colección de procesos no tenga un Kill método .
$p.Kill()
Get-Process Notepad
El Get-Process comando confirma que el Kill método funcionó.
Get-Process : Cannot find a process with the name "notepad". Verify the proc
ess name and call the cmdlet again.
At line:1 char:12
+ Get-Process <<<< notepad
+ CategoryInfo : ObjectNotFound: (notepad:String) [Get-Process]
, ProcessCommandException
+ FullyQualifiedErrorId : NoProcessFoundForGivenName,Microsoft.PowerShel
l.Commands.GetProcessCommand
Este ejemplo es funcionalmente equivalente al uso del Foreach-Object cmdlet para ejecutar el método en cada objeto de la colección.
$p | ForEach-Object {$_.Kill()}
Métodos ForEach y Where
A partir de PowerShell 4.0, se admite el filtrado de colecciones mediante una sintaxis de método. Esto permite el uso de dos nuevos métodos al tratar con colecciones ForEach y Where.
Puede obtener más información sobre estos métodos en about_arrays.
Llamar a un método específico cuando existen varias sobrecargas
Tenga en cuenta el siguiente escenario al llamar a métodos de .NET. Si un método toma un objeto pero tiene una sobrecarga a través de una interfaz que toma un tipo más específico, PowerShell elige el método que acepta el objeto a menos que lo convierta explícitamente en esa interfaz.
Add-Type -TypeDefinition @'
// Interface
public interface IFoo {
string Bar(int p);
}
// Type that implements the interface
public class Foo : IFoo {
// Direct member method named 'Bar'
public string Bar(object p) { return $"object: {p}"; }
// *Explicit* implementation of IFoo's 'Bar' method().
string IFoo.Bar(int p) {
return $"int: {p}";
}
}
'@
En este ejemplo se eligió la sobrecarga menos específica object del método Bar .
[Foo]::new().Bar(1)
object: 1
En este ejemplo, se convierte el método en la interfaz IFoo para seleccionar la sobrecarga más específica del método Bar .
([IFoo] [Foo]::new()).Bar(1)
int: 1
Uso de métodos de .NET que toman rutas de acceso del sistema de archivos
PowerShell admite varios espacios de ejecución por proceso. Cada espacio de ejecución tiene su propio directorio actual. Esto no es lo mismo que el directorio de trabajo del proceso actual: [System.Environment]::CurrentDirectory.
Los métodos de .NET usan el directorio de trabajo del proceso. Los cmdlets de PowerShell usan la ubicación del espacio de ejecución. Además, los métodos de .NET solo funcionan con rutas de acceso nativas del sistema de archivos, no con objetos Path de PowerShell. Para usar rutas de acceso de PowerShell con métodos de .NET, debe resolver la ruta de acceso a una ruta de acceso nativa del sistema de archivos antes de pasarla al método .NET.
