about_Methods

  • Article

Description courte

Décrit comment utiliser des méthodes pour effectuer des actions sur des objets dans PowerShell.

Description longue

PowerShell utilise des objets pour représenter les éléments dans les magasins de données ou l’état de l’ordinateur. Par exemple, les objets FileInfo représentent les fichiers dans les lecteurs de système de fichiers et les objets ProcessInfo représentent les processus sur l’ordinateur.

Les objets ont des propriétés, qui stockent des données sur l’objet et des méthodes qui vous permettent de modifier l’objet.

Une « méthode » est un ensemble d’instructions qui spécifient une action que vous pouvez effectuer sur l’objet. Par exemple, l’objet FileInfo inclut la CopyTo méthode qui copie le fichier que l’objet FileInfo représente.

Pour obtenir les méthodes d’un objet, utilisez l’applet Get-Member de commande. Utilisez sa propriété MemberType avec la valeur « Method ». La commande suivante obtient les méthodes des objets de traitement.

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...

Pour effectuer ou « appeler » une méthode d’un objet, tapez un point (.), le nom de la méthode et un ensemble de parenthèses « () ». Si la méthode a des arguments, placez les valeurs d’argument entre parenthèses. Les parenthèses sont requises pour chaque appel de méthode, même en l’absence d’arguments. Si la méthode accepte plusieurs arguments, elles doivent être séparées par des virgules.

Par exemple, la commande suivante appelle la méthode Kill des processus pour mettre fin au processus de Bloc-notes Windows sur l’ordinateur.

$notepad = Get-Process notepad
$notepad.Kill()

Cet exemple peut être raccourci en combinant les instructions ci-dessus.

(Get-Process Notepad).Kill()

La Get-Process commande est placée entre parenthèses pour s’assurer qu’elle s’exécute avant l’appel de la méthode Kill. La Kill méthode est ensuite appelée sur l’objet retourné Process .

Une autre méthode très utile est la Replace méthode des chaînes. La méthode remplace le Replace texte dans une chaîne. Dans l’exemple ci-dessous, le point (.) peut être placé immédiatement après la citation de fin de la chaîne.

'this is rocket science'.Replace('rocket', 'rock')

this is rock science

Comme indiqué dans les exemples précédents, vous pouvez appeler une méthode sur un objet que vous obtenez à l’aide d’une commande, d’un objet dans une variable ou de tout ce qui entraîne un objet (comme une chaîne entre guillemets).

À compter de PowerShell 4.0, l’appel de méthode à l’aide des noms de méthodes dynamiques est pris en charge.

Apprentissage sur les méthodes

Pour rechercher des définitions des méthodes d’un objet, accédez à la rubrique d’aide pour le type d’objet et recherchez sa page de méthodes. Par exemple, la page suivante décrit les méthodes des objets de processus System.Diagnostics.Process.

Pour déterminer les arguments d’une méthode, passez en revue la définition de la méthode, comme le diagramme de syntaxe d’une applet de commande PowerShell.

Une définition de méthode peut avoir une ou plusieurs signatures de méthode, qui sont similaires aux ensembles de paramètres d’applets de commande PowerShell. Les signatures affichent tous les formats valides de commandes à appeler la méthode.

Par exemple, la CopyTo méthode de la FileInfo classe contient les deux signatures de méthode suivantes :

    CopyTo(String destFileName)
    CopyTo(String destFileName, Boolean overwrite)

La première signature de méthode prend le nom du fichier de destination (et un chemin d’accès). L’exemple suivant utilise la première CopyTo méthode pour copier le Final.txt fichier dans le C:\Bin répertoire.

(Get-ChildItem c:\final.txt).CopyTo("c:\bin\final.txt")

Remarque

Contrairement au mode argument de PowerShell, les méthodes d’objet s’exécutent en mode expression, qui est un pass-through vers le .NET Framework sur lequel PowerShell est basé. En mode expression, les arguments nus (chaînes nonquoées) ne sont pas autorisés. Vous pouvez voir cette différence lors de l’utilisation d’un chemin d’accès en tant que paramètre, par rapport au chemin d’accès en tant qu’argument. Vous pouvez en savoir plus sur les modes d’analyse dans about_Parsing

La deuxième signature de méthode prend un nom de fichier de destination et une valeur booléenne qui détermine si le fichier de destination doit être remplacé, s’il existe déjà.

L’exemple suivant utilise la deuxième CopyTo méthode pour copier le Final.txt fichier dans le C:\Bin répertoire et remplacer les fichiers existants.

(Get-ChildItem c:\final.txt).CopyTo("c:\bin\final.txt", $true)

Énumération des accès aux membres

À compter de PowerShell 3.0, lorsque vous utilisez l’opérateur d’accès membre (.) pour accéder à une méthode qui n’existe pas dans une collection de listes, PowerShell énumère automatiquement les éléments de la collection et appelle la méthode sur chaque élément. Pour plus d’informations, consultez about_Member-Access_Enumeration.

Exemples

L’exemple suivant exécute la méthode Kill d’objets de processus individuels dans une collection d’objets.

La première commande démarre trois instances du processus de Bloc-notes Windows. Get-Processobtient les trois instances du processus Bloc-notes Windows et les enregistre dans la $p variable.

Notepad; Notepad; Notepad
$p = Get-Process Notepad
$p.Count

3

La commande suivante exécute la méthode Kill sur les trois processus de la $p variable. Cette commande fonctionne même si une collection de processus n’a pas de Kill méthode.

$p.Kill()
Get-Process Notepad

La Get-Process commande confirme que la Kill méthode a fonctionné.

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

Cet exemple équivaut fonctionnellement à l’utilisation de l’applet Foreach-Object de commande pour exécuter la méthode sur chaque objet de la collection.

$p | ForEach-Object {$_.Kill()}

Méthodes ForEach et Where

À compter de PowerShell 4.0, le filtrage de collection à l’aide d’une syntaxe de méthode est pris en charge. Cela permet l’utilisation de deux nouvelles méthodes lors de la gestion des collections ForEach et Where.

Vous pouvez en savoir plus sur ces méthodes dans about_arrays

Appel d’une méthode spécifique quand plusieurs surcharges existent

Tenez compte du scénario suivant lors de l’appel de méthodes .NET. Si une méthode prend un objet mais a une surcharge via une interface prenant un type plus spécifique, PowerShell choisit la méthode qui accepte l’objet, sauf si vous le cassez explicitement vers cette interface.

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}";
   }

}
'@

Dans cet exemple, la surcharge moins spécifique object de la méthode Bar a été choisie.

[Foo]::new().Bar(1)

object: 1

Dans cet exemple, nous allons convertir la méthode en IFoo d’interface pour sélectionner la surcharge plus spécifique de la méthode Bar.

([IFoo] [Foo]::new()).Bar(1)

int: 1

Utilisation de méthodes .NET qui prennent des chemins de système de fichiers

PowerShell prend en charge plusieurs runspaces par processus. Chaque runspace a son propre répertoire actif. Ce n’est pas le même que le répertoire de travail du processus actuel : [System.Environment]::CurrentDirectory.

Les méthodes .NET utilisent le répertoire de travail du processus. Les applets de commande PowerShell utilisent l’emplacement Runspace. En outre, les méthodes .NET fonctionnent uniquement avec des chemins de système de fichiers natifs, et non avec des objets PowerShell Path. Pour utiliser des chemins PowerShell avec des méthodes .NET, vous devez résoudre le chemin d’accès à un chemin natif du système de fichiers avant de le transmettre à la méthode .NET.

Voir aussi