Windows PowerShell est un environnement de commande-shell qui prend en charge le scriptage orienté objet basé sur le Microsoft .NET Framework. Son cœur est la cmdlet PowerShell, une commande légère qui exécute une action spécifique et, dans le processus, renvoie un objet .NET. PowerShell vous permet d’utiliser des cmdlets pour accéder à une variété de systèmes et effectuer de nombreuses tâches sur ces systèmes. Cependant, les cmdlets seuls ne suffisent pas toujours à réaliser certaines actions. Pour ces actions, vous devez souvent créer vos propres objets basés sur les classes .NET. Un type d’objet .NET que vous pouvez créer est l’objet personnalisé. Un objet personnalisé vous permet de définir les types de données affectées à cet objet et les actions qu’il peut effectuer. Après avoir compris comment construire un objet personnalisé, vous disposerez d’un outil puissant pour élaborer des scripts susceptibles d’étendre la portée déjà importante de PowerShell.
Notez que le .NET Framework et la programmation orientée objet sont des sujets complexes, qui dépassent largement le cadre du présent document. Pour apprécier pleinement la nature orientée objet de PowerShell, il peut être utile d’avoir au moins une compréhension de base de ces concepts. Pour plus d’informations sur le .NET Framework, voir l’article MSDN « Overview of the .NET Framework ». Pour une introduction à la programmation orientée objet, consultez l’article MSDN « Programmation orientée objet (C# et Visual Basic). »
Création d’un objet personnalisé
Pour créer un objet personnalisé dans PowerShell, vous devez d’abord utiliser la cmdlet New-Object pour construire l’objet initial. Cette cmdlet vous permet de créer des objets .NET ou COM à partir d’un assortiment de classes. Un objet personnalisé est un type particulier d’objet .NET basé sur la classe .NET Object ou PSObject. Il n’y a pas de différence entre les deux lors de la création de l’objet initial. Cependant, la classe PSObject est généralement préférée en raison des problèmes qui peuvent survenir lors de l’ajout de propriétés à un objet basé sur la classe Object, alors utilisons PSObject.
Pour créer un objet basé sur la classe PSObject, vous devez utiliser le cmdlet New-Object avec le paramètre -TypeName et spécifier la classe PSObject comme valeur du paramètre, comme suit :
$system = New-Object -TypeName PSObject
Lorsque vous exécutez cette commande, elle génère un objet PSCustomObject et l’affecte à la variable $system. Le plus souvent, vous voudrez affecter l’objet à une variable afin de pouvoir travailler facilement avec les membres de cet objet. Les membres sont les composants qui constituent un objet, tels que les propriétés, les méthodes, les propriétés alias et les ensembles de membres.
Lorsque vous travaillez avec des objets dans PowerShell, les deux types de membres que vous utiliserez probablement sont les propriétés et les méthodes. Une propriété décrit un aspect spécifique de l’objet. Par exemple, l’un des membres de la classe FileInfo .NET est la propriété Length, qui fournit la taille d’un fichier en octets. Si vous créez un objet FileInfo basé sur cette classe, vous pouvez utiliser la propriété Length pour accéder à la taille du fichier associé à cet objet. Une méthode exécute une action liée à l’objet. Par exemple, la classe FileInfo comprend également la méthode Delete, que vous pouvez utiliser pour supprimer le fichier représenté par l’objet.
Pouvoir identifier facilement les membres d’un objet facilite le travail avec cet objet. Pour obtenir une liste des membres qui composent un objet, vous pouvez utiliser le cmdlet Get-Member. Par exemple, pour consulter les membres du nouvel objet qui a été attribué à la variable $system, vous pouvez transmettre la variable $system à la cmdlet Get-Member :
$system | Get-Member
Comme le montre la figure 1, l’objet que vous avez créé est basé sur la classe System.Management.Automation.PSCustomObject, qui ne comprend qu’un petit nombre de membres, tous des méthodes. Mais c’est pourquoi on l’appelle un objet personnalisé – vous pouvez le personnaliser en ajoutant vos propres membres.
Avant de vous montrer comment ajouter des membres, laissez-moi juste ajouter que, comme beaucoup de classes .NET, la classe PSCustomObject comprend également un certain nombre de membres cachés de différents types, tels que memberset et codeproperty. Vous pouvez afficher ces membres en incluant le paramètre -Force lorsque vous appelez le cmdlet Get-Member. Bien qu’une discussion sur les membres cachés dépasse le cadre de cet article, vous pourriez trouver utile à un moment donné d’explorer les membres cachés disponibles pour la classe PSCustomObject et d’autres classes .NET afin de tirer pleinement parti de vos objets PowerShell.
Ajouter des propriétés à un objet personnalisé
Un objet personnalisé n’est aussi utile que les membres associés à l’objet. Vous pouvez ajouter plusieurs types de membres différents à un objet personnalisé. Dans cet exemple, vous allez ajouter les membres NoteProperty et ScriptMethod. Un membre NoteProperty est similaire à une propriété ordinaire, et un membre ScriptMethod est similaire à une méthode ordinaire. Vous ne pouvez pas ajouter une propriété ou une méthode ordinaire à un objet personnalisé, c’est pourquoi vous allez utiliser NoteProperty et ScriptMethod. (Pour plus d’informations sur les membres pris en charge dans un objet personnalisé, consultez la rubrique PowerShell TechNet « Add-Member. »)
Démarrons en ajoutant quelques membres NoteProperty à l’objet $system. Pour ajouter les membres, vous pouvez utiliser la cmdlet Add-Member pour définir les noms et les valeurs des propriétés. Par exemple, supposons que vous souhaitiez ajouter des propriétés de note basées sur des données récupérées par le biais des capacités de Windows Management Instrumentation (WMI) intégrées à PowerShell. (WMI fournit une infrastructure pour la gestion des données et des opérations dans les systèmes d’exploitation Windows). Le modèle d’objet WMI comprend de nombreuses classes qui prennent en charge un large éventail d’opérations de gestion. Par exemple, la classe Win32_OperatingSystem permet d’accéder à des informations telles que le nom du système d’exploitation installé sur un ordinateur et le dernier service pack appliqué à ce système d’exploitation.
Pour créer un objet WMI, vous utilisez la cmdlet Get-WmiObject et spécifiez la classe souhaitée. Par exemple, pour créer un objet WMI Win32_OperatingSystem et l’affecter à la variable $os, vous utiliseriez le code :
$os = Get-WmiObject Win32_OperatingSystem
Dans ce cas, vous récupérez les informations système de l’ordinateur local, mais la beauté de WMI est sa capacité à accéder également aux ordinateurs Windows distants et à les gérer.
Vous pouvez ensuite utiliser la variable $os pour accéder aux informations renvoyées par cet objet. L’affectation d’un objet à une variable de cette manière verrouille les données à ce moment précis. Par exemple, si un nouveau service pack est appliqué au système d’exploitation après que vous ayez créé la variable $os, la propriété CSDVersion de l’objet ne reflétera pas le changement car l’objet avait été créé sur la base des données d’origine.
Après avoir défini la variable $os, vous devez spécifier deux commandes Add-Member. Chaque commande prendra quatre paramètres :
- -InputObject. Vous utilisez le paramètre -InputObject pour identifier l’objet recevant les nouvelles propriétés de la note. Dans ce cas, vous devez spécifier l’objet $system.
- -MemberType. Le paramètre -MemberType indique le type de membre à créer, vous devez donc spécifier NoteProperty.
- -Name. Vous utilisez le paramètre -Name pour spécifier le nom du nouveau membre. Pour cet exemple, nommons le premier membre OperatingSystem et le second membre ServicePack.
- -Value. Ce paramètre spécifie la valeur du membre. Pour la première propriété de note, vous devez spécifier $os.Caption pour retourner le nom du système d’exploitation. Pour la deuxième propriété de note, vous devez spécifier $os.CSDVersion pour retourner le dernier service pack appliqué au système d’exploitation.
Voici à quoi ressemblent les deux commandes Add-Member :
Add-Member -InputObject $system -MemberType NoteProperty ` -Name OperatingSystem -Value $os.CaptionAdd-Member -InputObject $system -MemberType NoteProperty ` -Name ServicePack -Value $os.CSDVersion
Notez que j’ai cassé chaque commande Add-Member en deux lignes. À la fin de chaque première ligne, j’ai inclus une coche arrière (`) afin que le processeur PowerShell sache qu’il doit continuer à la ligne suivante pour la commande complète.
Après avoir exécuté les commandes Add-Member, vous pouvez appeler la variable $system pour voir son contenu :
$system
La figure 2 montre des exemples de résultats.
Vous pouvez également utiliser la variable $system pour appeler des membres individuels. Il suffit de spécifier le nom de la variable, suivi d’un point, puis du nom du membre. Par exemple, la commande suivante renvoie la valeur actuelle de la propriété de note OperatingSystem:
$system.OperatingSystem
Un avantage de la création d’un objet personnalisé est qu’il vous permet de créer des propriétés de note basées sur des données provenant de différentes sources ainsi qu’une propriété de note dont la valeur est une chaîne spécifique. Par exemple, regardez le code du Listing 1, qui ajoute trois nouvelles propriétés de note à l’objet $system.
$mem = Get-WmiObject Win32_PhysicalMemory$disk = Get-WmiObject Win32_DiskDriveAdd-Member -InputObject $system -MemberType NoteProperty ` -Name PhysicalMemory ` -Value (("{0:N2}" -f ($mem.Capacity/1GB)) + ' GB')Add-Member -InputObject $system -MemberType NoteProperty ` -Name DiskSize ` -Value (("{0:N2}" -f ($disk.Size/1GB)) + ' GB')Add-Member -InputObject $system -MemberType NoteProperty ` -Name Owner -Value "janetp"
La plupart des éléments du Listing 1, vous les avez vus dans l’exemple précédent. Cependant, remarquez que le code crée une instance de la classe Win32_PhysicalMemory, qui est affectée à la variable $mem, et une instance de la classe Win32_DiskDrive, qui est affectée à la variable $disk. Deux des propriétés de la note ajoutée utilisent ces nouveaux objets WMI comme sources de données.
La première commande Add-Member récupère les données de la propriété $mem.Capacity, qui fournit la capacité de la mémoire sur le système cible. Dans ce cas, cependant, le paramètre -Value est un peu plus complexe que ce que vous avez vu dans l’exemple précédent. Tout d’abord, la commande spécifie « {0:N2} » suivi de -f, qui est une construction .NET pour formater le nombre sorti. En gros, cela signifie qu’un nombre doit être renvoyé avec deux décimales. Les instructions de formatage sont suivies d’une expression courte ($mem.Capacity/1GB) qui divise la valeur de Capacity par 1GB. La valeur Capacity fournit la taille de la mémoire en octets. PowerShell permet de convertir facilement les octets en gigaoctets en divisant simplement par 1 Go. Enfin, la commande étiquette la chaîne ‘ GB’ (y compris l’espace) sur la sortie et met le tout entre parenthèses.
La deuxième commande Add-Member suit la même logique pour renvoyer la taille du disque dur de l’ordinateur. Elle utilise la propriété $disk.Size pour retourner la taille en octets, puis la convertit en gigaoctets.
La troisième commande Add-Member ajoute une propriété de note nommée Owner et lui attribue la valeur de chaîne janetp. Dans ce cas, « propriétaire » peut signifier n’importe quoi – l’utilisateur principal, le dernier utilisateur, l’administrateur, ou toute autre signification que vous voulez imposer à la propriété. Je l’ai inclus ici uniquement pour démontrer que vous pouvez ajouter une propriété de note dont la valeur est une simple chaîne.
Après avoir ajouté les trois membres à l’objet personnalisé, vous pouvez à nouveau appeler la variable $system. Elle renverra des résultats comme ceux présentés dans la figure 3.
Vous avez maintenant un seul objet qui contient des données dérivées de trois objets WMI différents. L’objet contient également la propriété Owner, qui est basée sur une valeur de chaîne. Vous pouvez appeler cette propriété note comme vous le feriez pour n’importe quel autre membre :
$system.Owner
Comme vous pouvez vous y attendre, la commande renvoie la valeur janetp. Cependant, vous pouvez changer cette valeur en une valeur différente en assignant une nouvelle valeur à la propriété, comme ceci:
$system.Owner = "rogert"
Dans ce cas, la valeur rogert a été assignée à la propriété de note Owner. Si vous appelez cette propriété note maintenant, elle renverra la nouvelle valeur.
Comme pour de nombreuses tâches que vous pouvez effectuer dans PowerShell, il existe différentes façons d’ajouter un membre à un objet personnalisé. Par exemple, PowerShell 3.0 vous permet de créer une table de hachage et de passer le hachage à la commande New-Object. Le code du Listing 2 crée les mêmes cinq propriétés de note mais utilise une table de hachage pour transmettre les noms et les valeurs des membres.
$info = @{ "OperatingSystem" = $os.Caption; "ServicePack" = $os.CSDVersion; "PhysicalMemory" = (("{0:N2}" -f ($mem.Capacity/1GB)) + ' GB'); "DiskSize" = (("{0:N2}" -f ($disk.Size/1GB)) + ' GB'); "Owner" = 'janetp'}$system = New-Object -TypeName PSObject -Property $info$system
Ce code crée d’abord une table de hachage qui définit cinq paires propriété/valeur, chacune correspondant aux propriétés de la note. Comme le montre le code, vous devez séparer les paires propriété/valeur par des points-virgules. Vous devez également placer l’ensemble des cinq paires propriété/valeur entre crochets et faire précéder le crochet ouvrant du symbole at (@). Enfin, vous devez affecter la table de hachage à la variable $info.
Après avoir défini la table de hachage, le code utilise le cmdlet New-Object pour créer un objet basé sur la classe PSObject et l’affecter à la variable $system. Seulement cette fois, la commande inclut le paramètre -Property, qui prend la variable $info comme valeur.
Enfin, le code appelle la variable $system, qui renvoie des résultats comme ceux de la figure 4. Remarquez l’ordre dans lequel les propriétés ont été ajoutées à l’objet. L’un des problèmes liés à l’utilisation d’une table de hachage pour ajouter des propriétés de note est que vous ne pouvez pas contrôler leur ordre. Pour contrôler l’ordre, vous devez utiliser le cmdlet Add-Member pour ajouter chaque membre.
Ajouter des méthodes à un objet personnalisé
Maintenant que vous avez vu à quel point il est facile d’ajouter des propriétés, d’accéder à leurs valeurs et de modifier ces valeurs, passons aux méthodes. Celles-ci deviennent un peu plus compliquées parce que les méthodes doivent faire quelque chose, et vous devez définir ce quelque chose comme faisant partie de la valeur de la méthode.
Par exemple, le code dans le Listing 3 crée une méthode qui récupère la date et l’heure actuelles et les renvoie à la fois dans leur format d’origine et comme valeurs de temps universel coordonné (UTC).
$method ={ $a = Get-Date -Format F; "Local: " + $a; $b = Get-Date; "UTC: " + $b.ToUniversalTime().DateTime}Add-Member -InputObject $system -MemberType ScriptMethod ` -Name GetUTC -Value $method
Pour garder le code lisible, vous pouvez affecter la valeur de la méthode à une variable (par exemple, $method). Cette valeur comprend les expressions nécessaires pour renvoyer les informations de date et d’heure. Toutefois, vous devez définir la valeur sous forme de bloc de script afin de la transmettre à la commande Add-Member. Pour ce faire, vous devez mettre le contenu de la valeur entre crochets. PowerShell affectera alors la valeur sous sa forme actuelle à la variable en tant qu’objet ScriptBlock.
Dans le Listing 3, la valeur de la méthode comprend deux expressions. La première expression renvoie la date et l’heure actuelles, et la seconde expression renvoie la version UTC. Vous commencez la première expression en utilisant le cmdlet Get-Date pour récupérer la date et l’heure actuelles, que vous affectez à la variable $a. Notez que lorsque vous appelez la cmdlet Get-Date, vous devez inclure le paramètre -Format, avec la valeur F. Cela indique à PowerShell d’afficher l’horodatage dans un format de date et d’heure complet, comme dans Monday, August 19, 2013 12:28:25 PM. Vous ajoutez ensuite la chaîne « Local : » (y compris l’espace) à la valeur de la variable pour renvoyer la date et l’heure actuelles avec cette étiquette.
Dans la deuxième expression, vous commencez à nouveau avec le cmdlet Get-Date pour renvoyer la date et l’heure actuelles, que vous affectez à la variable $b. Vous utilisez ensuite la méthode ToUniversalTime de la variable pour renvoyer la date et l’heure sous forme de valeur UTC, puis vous spécifiez la propriété DateTime pour renvoyer le format correct.
Si vous deviez appeler la variable $method à ce stade, elle renverrait les deux expressions sous forme de chaînes de caractères, exactement comme elles ont été tapées. Parce que vous avez défini la valeur de la variable comme un bloc de script, les commandes ne sont pas traitées lorsqu’elles sont affectées à la variable $method. Au lieu de cela, la variable $method est créée comme un objet ScriptBlock, ce que vous pouvez confirmer en utilisant la méthode GetType pour voir le type de la variable :
$method.GetType()
Pour travailler avec le bloc de script, vous devez ajouter la méthode comme membre de l’objet $system après avoir défini la variable $method. Pour ce faire, vous créez une commande Add-Member qui spécifie ScriptMethod comme type, GetUTC comme nom et la variable $method comme valeur.
Après avoir exécuté le code du Listing 3, vous pouvez utiliser la variable $system pour appeler la méthode GetUTC de la même manière que vous avez appelé les propriétés :
$system.GetUTC()
Notez cependant que lorsque vous appelez la méthode script, vous devez inclure les parenthèses, comme vous le faites pour toute autre méthode, même si vous ne passez pas d’arguments. La méthode devrait maintenant retourner des résultats similaires à ceux de la figure 5, mais avec la date et l’heure auxquelles vous avez appelé la méthode.
Dans la vraie vie, vous voudrez probablement créer des méthodes qui ont plus de punch. Par exemple, l’objet $system pourrait intégrer des tâches de gestion WMI dans ses méthodes de script. Si vous le faites, vous devez tester complètement la méthode pour vous assurer que vos commandes font exactement ce qu’elles sont censées faire. PowerShell et WMI sont tous deux des outils puissants, ils doivent donc être utilisés avec précaution lors de la gestion des ordinateurs Windows.
Ajouter des objets personnalisés à un tableau
Les objets personnalisés ne se limitent pas à des objets autonomes que vous utilisez une fois et que vous mettez de côté. Vous pouvez ajouter ces objets à un tableau d’objets, puis accéder aux objets par le biais de ce tableau. Par exemple, supposons que vous souhaitiez manipuler des informations récupérées sur plusieurs ordinateurs. Ces informations peuvent inclure des détails sur la mémoire et les lecteurs logiques disponibles sur ces systèmes. Vous voulez être en mesure de travailler avec ces détails de manière significative dans PowerShell. En raison de la nature orientée objet de PowerShell, mettre ces informations dans des objets est souvent la façon la plus simple de travailler avec ces données.
Voyons un exemple de la façon dont vous pourriez le faire. Pour cette discussion, l’approche utilisée pour collecter les informations sur les différents ordinateurs n’a pas d’importance. Vous pourriez, par exemple, mettre en place une boucle foreach dans PowerShell qui utilise WMI pour récupérer les informations des différents postes de travail. Quelle que soit la méthode utilisée, par souci de concision, supposez que vous avez collecté les informations dans un fichier texte séparé par des virgules qui contient les données illustrées à la figure 6.
Le fichier texte comprend une ligne d’en-tête et une ligne pour les lecteurs logiques de chaque système. Par exemple, la première ligne de données fournit des détails sur le lecteur logique C de l’ordinateur ws01. Le lecteur logique a une capacité de 500 Go, avec 225 Go d’espace libre. Le système dispose également de 4 Go de mémoire. La deuxième rangée indique que le même ordinateur contient également le lecteur logique D, qui a la même capacité que le lecteur C mais avec 320 Go d’espace libre.
Le but est de transformer chaque rangée de données en son propre objet personnalisé, puis d’ajouter ces objets à un tableau. Vous pouvez ensuite agir sur les objets du tableau en acheminant les données vers d’autres commandes PowerShell. Le code du Listing 4 définit un tableau vide, importe les données du fichier texte, puis utilise une boucle foreach pour créer les objets et les ajouter au tableau.
$SystemInfo = @()$SourceData = Import-CSV C:\DataFiles\SourceData.txtforeach ($source in $SourceData){ $system = New-Object -TypeName PSObject $system | Add-Member -Type NoteProperty ` -Name Computer -Value $source.Computer $system | Add-Member -Type NoteProperty ` -Name DeviceID -Value $source.DeviceID $system | Add-Member -Type NoteProperty ` -Name DriveSize -Value ($source.DriveSize) $system | Add-Member -Type NoteProperty ` -Name UsedSpace ` -Value ($source.DriveSize - $Source.FreeSpace) $system | Add-Member -Type NoteProperty ` -Name FreeSpace -Value ($source.FreeSpace) $SystemInfo += $system}
Comme vous pouvez le voir, la première étape consiste à créer le tableau vide (@()) et à l’affecter à la variable $SystemInfo. Éventuellement, vous ajouterez les objets personnalisés à ce tableau.
Puis, vous utilisez la cmdlet Import-CSV pour importer les données dans la variable $SourceData. Pour cet exercice, le fichier texte est nommé SourceData.txt et enregistré dans le dossier C:\DataFiles. La cmdlet Import-CSV récupère chaque ligne comme son propre objet et l’enregistre dans $SourceData. À ce stade, vous pourriez utiliser cette variable pour accéder aux données, mais vous n’auriez aucun contrôle sur les membres inclus dans l’objet, et vous ne seriez pas en mesure d’ajouter des membres.
L’étape suivante consiste donc à créer une boucle foreach qui vous permet de créer un objet personnalisé pour chaque ligne du fichier texte. La condition foreach ($source in $SourceData) spécifie que chaque ligne de $SourceData doit être affectée à la variable $source à mesure que le code itère dans la boucle foreach. La logique définie dans le bloc de script foreach (entre crochets) sera alors exécutée une fois pour chaque ligne, un objet $source différent étant appliqué à chaque itération. (Pour plus d’informations sur la création d’une boucle foreach, consultez la rubrique PowerShell TechNet about_ForEach.)
Regardons de plus près le bloc de script foreach. La première commande crée l’objet initial et l’enregistre dans la variable $system, comme vous l’avez vu dans les exemples précédents. Ensuite, la variable $system est dirigée vers une commande Add-Member afin de créer la première propriété note. Le format est légèrement différent de celui utilisé précédemment. Au lieu d’inclure le paramètre -InputObject dans la commande Add-Member, vous acheminez simplement $system vers la commande. On obtient ainsi les mêmes résultats que dans les exemples précédents de commandes Add-Member. J’ai adopté cette approche ici simplement pour démontrer une autre façon dont PowerShell vous permet d’ajouter des membres.
Pour la valeur de la commande Add-Member, vous utilisez la variable $source pour appeler la propriété Computer, qui correspond au champ Computer dans les données source. La deuxième commande Add-Member fonctionne de la même manière, sauf qu’elle récupère les données de la propriété DeviceID. Remarquez que la propriété Memory n’est pas incluse. Lorsque vous créez un objet personnalisé, vous pouvez omettre certaines propriétés ou les placer dans un ordre différent.
La troisième commande Add-Member fonctionne à peu près de la même manière que les deux premières, sauf qu’elle accède à la propriété DriveSize. Parce que vous pourriez vouloir travailler avec ces données comme une valeur numérique plutôt qu’une chaîne de caractères, la commande convertit explicitement les données en un nombre. Ceci est réalisé en faisant précéder le nom de la propriété par pour indiquer que vous voulez le type de donnéesint, puis en mettant l’expression entière de la propriété entre parenthèses.
La quatrième commande Add-Member fait quelque chose d’un peu différent. Elle crée un membre calculé qui soustrait la valeur FreeSpace de la valeur DriveSize afin de déterminer la quantité d’espace utilisé. Là encore, le nom de la propriété est précédé de et l’expression entière est placée entre parenthèses. Pouvoir créer une propriété calculée est l’une des principales raisons pour lesquelles vous pourriez vouloir créer des objets personnalisés.
La dernière commande Add-Member fonctionne comme la troisième, sauf qu’elle récupère les données de la propriété FreeSpace.
La dernière commande du bloc de script foreach ajoute l’objet $system actuel au tableau $SystemInfo. Remarquez que l’opérateur += est utilisé pour s’assurer que le nouvel objet $system est ajouté à chaque itération de la boucle, sans que rien ne soit écrasé.
Après avoir exécuté le code du Listing 4, vous pouvez appeler la variable pour afficher son contenu. La figure 7 montre une liste partielle des données maintenant stockées dans le tableau $SystemInfo.
Spécifiquement, elle montre les données des sept premiers objets du tableau, ce qui correspond aux sept premières lignes de données du fichier texte original. Chaque groupement représente l’un des objets ajoutés au tableau $SystemInfo. Vous pouvez vérifier que vous avez créé un tableau d’objets en utilisant la méthode GetType pour récupérer le type de la variable :
$SystemInfo.GetType()
Si cette commande renvoie un BaseType de System.Array, la variable $SystemInfo est bien un tableau d’objets capable de contenir des objets personnalisés. Vous pouvez alors utiliser cette variable pour manipuler les données comme bon vous semble. Par exemple, vous pouvez acheminer la variable vers une commande Sort-Object pour trier les données par ordre décroissant, en fonction des valeurs de FreeSpace :
$SystemInfo | Sort FreeSpace -Descending
Dans ce cas, la commande utilise l’alias Sort pour référencer la cmdlet Sort-Object et inclut la propriété FreeSpace et le paramètre -Descending. Comme vous pouvez le voir à la Figure 8, les objets sont maintenant répertoriés en fonction des valeurs de FreeSpace, le plus grand espace libre étant répertorié en premier. Encore une fois, ce n’est qu’une liste partielle.
Vous pouvez également trier les données en fonction de plusieurs colonnes. Par exemple, vous pouvez trier les données d’abord par la propriété Ordinateur, puis par la propriété Espace libre, par ordre décroissant :
$SystemInfo | Sort Computer, FreeSpace -Descending
Comme vous pouvez vous y attendre, les résultats sont maintenant très différents, comme le montre la figure 9.
L’une des conséquences du tri des colonnes de cette manière est que les valeurs Computer ainsi que les valeurs FreeSpace sont triées par ordre décroissant. La cmdlet Sort-Object ne vous permet pas de trier facilement une colonne dans l’ordre croissant et une autre dans l’ordre décroissant. Si vous spécifiez le paramètre -Descending, toutes les données sont triées dans cet ordre. Cependant, vous pouvez contourner cette limitation en créant des expressions pour chaque propriété qui spécifient comment trier ces valeurs. Par exemple, la commande suivante trie d’abord par la propriété Computer en ordre croissant, puis par la propriété FreeSpace en ordre décroissant :
$SystemInfo | Sort ` @{Expression="Computer"; Descending=$false}, @{Expression="FreeSpace"; Descending=$true}
La première expression Sort-Object définit la propriété Expression sur Computer et la propriété Descending sur $false. La deuxième expression définit la propriété Expression à FreeSpace et la propriété Descending à $true. (Les variables $true et $false sont des variables système intégrées qui fournissent les valeurs booléennes vrai et faux de 1 et 0, respectivement). Vous devez ensuite placer chaque expression entre crochets et faire précéder chaque crochet ouvrant du symbole at (@). Maintenant, les données seront triées dans l’ordre souhaité, comme le montre la figure 10.
Cela peut sembler exagéré sur le sujet du tri, mais cela souligne la flexibilité de travailler avec des objets dans un tableau. Et vous n’êtes certainement pas limité à la cmdlet Sort-Object. Par exemple, la commande suivante transmet la variable $SystemInfo à la cmdlet Where-Object:
$SystemInfo | Where DriveSize -gt 250 | Sort FreeSpace -Descending
Dans ce cas, la commande utilise l’alias Where pour référencer la cmdlet Where-Object. En outre, elle spécifie que la valeur DriveSize doit être supérieure à 250 pour être incluse dans les résultats. (Dans PowerShell, -gt est utilisé pour l’opérateur supérieur à.) Les résultats répondant à ces critères sont acheminés vers la cmdlet Sort-Object afin que les données soient affichées dans le bon ordre.
Vous pouvez même acheminer les données triées vers une commande Select-Object, comme ceci :
$SystemInfo | Where DriveSize -gt 250 | Sort FreeSpace -Descending | Select -First 5
Cette commande utilise la cmdlet Select-Object (référencée par l’alias Select) pour retourner uniquement les cinq premières lignes de l’ensemble de résultats. Comme vous pouvez le voir, une fois que vous ajoutez des objets personnalisés au tableau $SystemInfo, vous disposez d’une variété d’options pour travailler avec ces objets.
Making the Most of Your Custom Objects
Pour la plupart, la création d’objets personnalisés dans PowerShell est un processus assez simple. S’il y a une quelconque complexité impliquée, elle provient généralement des expressions de valeur que vous définissez pour vos propriétés de note ou méthodes de script. Les expressions utilisées dans ces exemples sont relativement simples par rapport aux types d’expressions que vous pouvez créer dans PowerShell. Malgré tout, ce que vous avez vu ici devrait vous fournir les bases dont vous avez besoin pour créer des objets personnalisés. Utilisés efficacement, ils peuvent constituer un composant puissant de vos scripts PowerShell, que vous créiez des objets individuels, les ajoutiez à un tableau ou les utilisiez d’une autre manière. Vous pouvez, par exemple, créer des objets personnalisés dans votre profil PowerShell afin qu’ils soient disponibles chaque fois que vous démarrez une nouvelle session. La façon dont vous utilisez les objets personnalisés dans vos scripts vous appartient. Sachez simplement que l’objet personnalisé est un outil efficace et flexible qui peut répondre à bon nombre de vos besoins en matière de scripts.
Pour plus d’informations sur la création d’objets personnalisés dans Windows PowerShell, consultez l’article de Bill Stewart intitulé « Creating Custom Objects in Windows PowerShell. »