Classes PowerShell : Premiers pas – techsyncer

PowerShell est un langage orienté objet. Lorsque vous exécutez des commandes, vous visualisez la sortie à l’écran, il s’agit d’objets. Les objets ne surgissent pas de nulle part ; les développeurs les créent, ou plus précisément, les instancient avec des classes. Les classes PowerShell représentent les définitions ou schémas de ces objets.

Bien que vous soyez peut-être familier avec la création d’objets à l’aide de commandes telles que New-Object et l’utilisation de l’accélérateur de type pscustomobject, ces objets ne sont pas vraiment « nouveaux ». Les types d’objets produits par ces méthodes sont d’un type spécifique. Les classes PowerShell définissent ce type.

Dans ce tutoriel, vous allez apprendre comment démarrer avec les classes PowerShell. Vous allez créer votre première classe avec des constructeurs, apprendre à créer des objets à partir de votre classe et enrichir votre classe avec des propriétés et des méthodes.

Pour des explications sur des termes tels que objets, propriétés et méthodes, consultez l’article de blog Retour aux bases : Comprendre les objets PowerShell.

Prérequis

Création de Votre première classe et objet

Avant de plonger dans les détails d’une classe PowerShell, vous devriez d’abord créer une classe simple. Vous découvrirez des sujets plus avancés plus tard.

Créer votre première classe aura un peu la même sensation que créer une fonction. La syntaxe de base est la même. Une classe est créée à partir d’une définition comme une fonction. Contrairement aux fonctions cependant, la première ligne ne commence pas par function suivi du nom de la fonction, mais elle commence par class suivi du nom de votre type d’objet.

Vous verrez ci-dessous le squelette de base d’une classe appelée étudiant.

class student {

}

Les classes ont des propriétés qui ressemblent à des paramètres qui sont des attributs décrivant cette classe. L’exemple ci-dessous montre une classe appelée étudiant avec deux propriétés ; FirstName et LastName.

Lorsque vous définissez une propriété, vous devriez toujours définir un type qui définit un « schéma » spécifique pour ce que les valeurs de propriété peuvent contenir. Dans l’exemple ci-dessous, les deux propriétés sont définies comme des chaînes de caractères.

Vous devriez toujours définir les types de propriétés. Vous comprendrez pourquoi plus tard.

class student {
    [string]$FirstName
    [string]$LastName
}

Après avoir défini une classe, créez un objet à partir de celle-ci ou instanciez un objet. Il existe plusieurs façons d’instancier des objets à partir de classes ; une façon courante est d’utiliser des accélérateurs de type tels que [étudiant] qui représentent la classe, suivis d’une méthode par défaut qui accompagne chaque classe appelée new().

L’utilisation du raccourci de l’accélérateur de type est la même que la création d’un objet à l’aide de la commande New-Object.

New-Object -TypeName student

Une fois que vous avez créé un objet à partir de cette classe, attribuez ensuite des valeurs aux propriétés. L’exemple ci-dessous attribue les valeurs de Tyler et Muir aux propriétés FirstName et LastName.

class student {
    [string]$FirstName
    [string]$LastName
}
$student1 = [student]::new()
$student1.FirstName = 'Tyler'
$student1.LastName = 'Muir'
$student1

Une fois que vous avez créé l’objet et attribué des valeurs aux propriétés, inspectez l’objet en appelant la variable à laquelle vous avez attribué l’objet, comme indiqué ci-dessous.

Creating an object from the student class.

Maintenant que vous avez créé un objet à partir d’une classe, envoyez cet objet comme n’importe quel autre objet dans PowerShell vers la cmdlet Get-Member pour l’inspecter. Vous pouvez voir ci-dessous que l’objet contenu dans la variable $student1 est de type student.

Le nom de la classe correspondra toujours au type d’objet.

Remarquez que Get-Member renvoie quatre méthodes et deux propriétés. Les propriétés sont probablement familières, mais les méthodes, pas tellement. PowerShell ajoute certaines méthodes par défaut, mais vous pouvez ajouter vos propres méthodes ou même modifier les méthodes par défaut.

Showing members from custom student object.

Création de méthodes

Dans l’exemple ci-dessus, vous avez vu quelques méthodes par défaut sur l’objet, mais il est probable que vous voudrez créer les vôtres. Pour ce faire, vous devez définir une ou plusieurs méthodes à l’intérieur de la définition de la classe.

A method definition looks like below with an output type that defines what type of object is returned from this method, the name of the method, and the code to execute inside of a scriptblock.

[<output type>]<name>() {
	<code that runs when the method is executed>
}

Remarquez les parenthèses () après le nom. C’est là que vous pouvez définir les paramètres de la méthode (abordés plus tard). Les paramètres de méthode vous permettent de modifier la fonctionnalité d’une méthode tout comme vous le feriez avec les paramètres de fonction.

Si vous avez déjà écrit et exécuté des fonctions PowerShell auparavant, les blocs de script de méthode devraient vous sembler familiers, mais il existe quelques règles spéciales pour les méthodes que vous devriez connaître.

`return` est obligatoire

Les fonctions PowerShell renverront des objets en plaçant simplement l’objet n’importe où dans la fonction comme dans l’exemple ci-dessous.

function foo {
	$object = Get-Service
	$object ## Envoi simplement l'objet vers le pipeline
}

Cependant, contrairement aux fonctions, si une méthode renvoie un objet, vous devez utiliser la construction return comme indiqué ci-dessous.

[string]GetName() {
	return 'foo'
}

Utilisation de la variable `$this`

Une autre différence entre les méthodes et les fonctions est la variable $this. La variable $this, telle que définie à l’intérieur d’une méthode, fait référence aux propriétés ou autres méthodes de l’objet actuel.

Voici un exemple d’une méthode appelée GetName() ajoutée à la classe student qui concatène la valeur des propriétés FirstName et LastName et les renvoie.

class student {
    [string]$FirstName
    [string]$LastName
    
    [string]GetName() {
        return "$($this.FirstName) $($this.LastName)"
    }
}

Maintenant, vous pouvez appeler la méthode GetName() en utilisant la notation pointée comme indiqué ci-dessous. Si vous avez précédemment attribué des valeurs à FirstName et LastName, GetName() les renverra.

Creating a class with a method and showing to output.

Ajout de paramètres aux méthodes

Dans l’exemple ci-dessus, lorsque vous avez exécuté la ligne $student1.GetName(), vous appeliez la méthode GetName() telle quelle. À l’intérieur des parenthèses, vous pouvez définir des paramètres comme pour les fonctions.

La méthode GetName() renvoyait simplement les valeurs définies pour les propriétés FirstName et LastName. Mais que faire si vous préférez avoir une méthode pour définir les propriétés que GetName() peut ensuite obtenir? Dans ce cas, vous devez définir les paramètres de méthode.

Définissez les paramètres de méthode en incluant un ou plusieurs paramètres séparés par une virgule entre les parenthèses des paramètres de méthode, comme illustré ci-dessous.

Notez le type de sortie [void]. Chaque fois qu’une méthode ne produit rien en sortie, vous n’avez pas besoin d’une structure return, et vous devez définir le type de sortie comme [void] pour indiquer à PowerShell que la méthode ne renvoie rien.

[void]SetName([string]$Name) {

}

Par exemple, peut-être que la méthode SetName() accepte un nom complet (prénom et nom de famille). Si c’est le cas, dans le scriptblock, vous pouvez ensuite diviser cette chaîne et attribuer le prénom et le nom de famille de cette manière.

En insérant la méthode SetName() dans la classe student, voici à quoi elle ressemble maintenant.

class student {
    [string]$FirstName
    [string]$LastName
    
    [string]GetName() {
        return "$($this.FirstName) $($this.LastName)"
    }
    
    [void]SetName([string]$Name) {
        $this.FirstName = ($Name -split ' ')[0]
        $this.LastName = ($Name -split ' ')[1]
    }
}

Maintenant, vous pouvez passer un nom complet en tant que paramètre à la méthode SetName(), qui définit les propriétés FirstName et LastName de l’objet actuel.

Creating a class with a void method and showing the output when it is run.

Surcharger les méthodes

Peut-être souhaitez-vous définir différents ensembles de paramètres pour une méthode. De manière similaire au fonctionnement des ensembles de paramètres dans les fonctions et les cmdlets, vous pouvez définir différents « contextes » de paramètres ou signatures de méthode.

Peut-être souhaitez-vous définir les paramètres FirstName et LastName en passant un nom complet à la méthode SetName() ou en passant le prénom et le nom séparément. Vous n’avez pas à choisir; vous pouvez les définir tous les deux avec les signatures de méthode.

Lorsque vous définissez plusieurs signatures de méthode dans une classe, cela s’appelle la surcharge.

En réutilisant l’exemple de la section précédente, vous pouvez créer une surcharge pour la méthode SetName() afin d’accepter deux chaînes au lieu d’une. Lorsque vous passez deux chaînes au lieu d’une, la méthode SetName() suppose que la première chaîne est le FirstName et la deuxième chaîne est le LastName. Avec cette surcharge, la classe ressemblerait à ce qui suit.

class student {
    [string]$FirstName
    [string]$LastName
    
    [string]GetName() {
        return "$($this.FirstName) $($this.LastName)"
    }
    
    [void]SetName([string]$Name) {
        $this.FirstName = ($Name -split ' ')[0]
        $this.LastName = ($Name -split ' ')[1]
    }
    
    [void]SetName([string]$FirstName,[string]$LastName) {
        $this.FirstName = $FirstName
        $this.LastName = $LastName
    }
}

Showing that the method overload works by providing either one or two strings.

Constructeurs de classe

Chaque fois que vous instanciez un objet avec la méthode new() ou d’une autre manière, vous pouvez indiquer à PowerShell d’exécuter un code défini par l’utilisateur appelé constructeur. Les constructeurs sont comme des méthodes, mais ils s’exécutent automatiquement lorsque PowerShell instancie un objet.

Chaque classe a un constructeur par défaut. Ce constructeur par défaut ne fait pas grand-chose ; il est simplement chargé d’instancier l’objet. Vous pouvez voir le constructeur par défaut en visualisant la sortie de la méthode New. Vous pouvez voir ci-dessous que cette ligne renvoie une seule méthode new().

[student]::New

Surcharge de constructeur

Peut-être que vous aimeriez définir une valeur pour les propriétés FirstName et LastName dès la création de l’objet, et non pas avec la notation habituelle par point. Dans ce cas, vous pouvez créer un constructeur avec un paramètre qui appelle ensuite SetName().

Voici un exemple de constructeur pour la classe student. Remarquez que le constructeur n’a pas de nom spécifique ou n’est pas précédé d’un type de sortie. Les constructeurs utilisent toujours le même nom que la classe.

Appeler une méthode existante dans le constructeur nous permet de réutiliser la méthode que nous avons déjà écrite pour manipuler la définition des variables.

student([string]$Name) {
	$this.SetName($Name)
}

Et ci-dessous, vous verrez ce constructeur ajouté à la classe student.

class student {
    [string]$FirstName
    [string]$LastName
    
    student([string]$Name) {
        $this.SetName($Name)
    }

    [string]GetName() {
        return "$($this.FirstName) $($this.LastName)"
    }
    
    [void]SetName([string]$Name) {
        $this.FirstName = ($Name -split ' ')[0]
        $this.LastName = ($Name -split ' ')[1]
    }

    [void]SetName([string]$FirstName,[string]$LastName) {
        $this.FirstName = $FirstName
        $this.LastName = $LastName
    }
}

Lorsque vous instanciez un nouvel objet student et que vous passez un paramètre de chaîne, les propriétés de l’objet auront immédiatement les valeurs attendues.

Showing the output from using the constructor with a string

Maintenant, vous pouvez voir à nouveau le constructeur surchargé avec [student]::New. Remarquez maintenant que le nouveau constructeur surchargé est défini avec un paramètre Name.

Définition d’un constructeur par défaut et surchargé

Maintenant que vous avez un constructeur surchargé sur votre classe student, PowerShell écrase le constructeur par défaut. Mais vous pouvez le récupérer en en créant un manuellement sans paramètres.

student() {}

Vous pouvez voir à quoi cela ressemble dans la classe student ci-dessous.

class student {
    [string]$FirstName
    [string]$LastName

    student([string]$Name) {
        $this.SetName($Name)
    }

    student() {}

    [void]SetName([string]$Name) {
        $this.FirstName = ($Name -split ' ')[0]
        $this.LastName = ($Name -split ' ')[1]
    }
}

Maintenant, vérifiez à nouveau les constructeurs. Vous verrez maintenant apparaître les deux constructeurs.

[student]::New

Creating a default and custom constructor

Héritage de classe

Comme toutes les autres langues orientées objet, vous pouvez construire des classes PowerShell de manière hiérarchique avec plusieurs classes. Chaque classe peut avoir des classes « parent » et « enfant » qui partent d’objectifs moins spécifiques, plus génériques, et augmentent en spécificité.

Par exemple, notre classe student représente un étudiant universitaire (enfant/spécifique). Cet étudiant universitaire est une personne (parent/générique). Ces deux concepts sont liés et forment une hiérarchie.

A child class can inherit a parent class which means it can hold all properties and methods (members) defined via a parent class. We know that a person class may have properties like eye_color, height, and weight and perhaps a method called SetHeight().

Si un étudiant est une personne, cet étudiant possède toujours ces propriétés et méthodes. Il serait redondant d’implémenter les mêmes membres sur la classe student que la classe person a déjà. Vous pouvez définir l’héritage de classe pour définir automatiquement tous les membres de la classe person sur la classe student.

Si cela n’a pas de sens maintenant, cela en aura lorsque nous passerons par une démo.

Démonstration d’héritage de classe

Tout d’abord, faites une copie de la classe student que vous avez créée précédemment, supprimez les constructeurs et renommez-la en une classe person. Votre classe person devrait ressembler à la classe ci-dessous.

A student, of course, has a first name and last name, but the class can be described more accurately by labeling it as a person. When creating a more “generic” class like this, you can create more specific “child” classes from it.

class person {
    [string]$FirstName
    [string]$LastName
    
    [string]GetName() {
        return "$($this.FirstName) $($this.LastName)"
    }
    
    [void]SetName([string]$Name) {
        $this.FirstName = ($Name -split ' ')[0]
        $this.LastName = ($Name -split ' ')[1]
    }

    [void]SetName([string]$FirstName,[string]$LastName) {
        $this.FirstName = $FirstName
        $this.LastName = $LastName
    }
}

Maintenant, créez quelques classes qui représentent une personne mais ont un rôle plus spécifique. Par exemple, dans le extrait de code ci-dessous, vous avez maintenant une classe teacher et student.

class teacher {
    [int]$EmployeeId
}

class student {
    [int]$StudentId
}

En l’état, les classes teacher et student sont mutuellement exclusives de la classe person. Elles n’ont aucune relation mais ne peuvent pas hériter des membres de la classe person. Changeons cela.

Définissez maintenant cette hiérarchie en définissant les classes teacher et student comme des classes « enfant » de la classe person avec l’héritage. Vous pouvez définir l’héritage en ajoutant deux points (:) après le nom de la classe suivi du nom de la classe parente comme indiqué ci-dessous.

class teacher : person {
    [int]$EmployeeId
}

class student : person {
    [int]$StudentId
}

Votre script de classe entier devrait maintenant ressembler à ceci:

class person {
    [string]$FirstName
    [string]$LastName
    
    [string]GetName() {
        return "$($this.FirstName) $($this.LastName)"
    }
    
    [void]SetName([string]$Name) {
        $this.FirstName = ($Name -split ' ')[0]
        $this.LastName = ($Name -split ' ')[1]
    }

    [void]SetName([string]$FirstName,[string]$LastName) {
        $this.FirstName = $FirstName
        $this.LastName = $LastName
    }
}

class teacher : person {
    [int]$EmployeeId
}

class student : person {
    [int]$StudentId
}

À ce stade, lorsque vous instanciez un objet à partir de la classe teacher ou student, les deux classes auront les mêmes membres que la classe person.

Héritage avec constructeurs

Comme vous l’avez vu précédemment, les méthodes de classe sont héritées via l’héritage de classe. Ce comportement peut vous amener à penser que les constructeurs suivraient la même logique, mais vous auriez tort. Les constructeurs ne sont pas hérités, et les constructeurs de toutes les classes enfant doivent être définis dans chaque classe enfant séparément.

Par exemple, peut-être avez-vous simplement défini un constructeur surchargé pour la classe person mais n’avez pas défini de constructeur pour la classe teacher, comme indiqué ci-dessous.

class person {
    [string]hidden $FirstName
    [string]$LastName
    
    [string]GetName() {
        return "$($this.FirstName) $($this.LastName)"
    }
    
    [void]SetName([string]$Name) {
        $this.FirstName = ($Name -split ' ')[0]
        $this.LastName = ($Name -split ' ')[1]
    }

    [void]SetName([string]$FirstName,[string]$LastName) {
        $this.FirstName = $FirstName
        $this.LastName = $LastName
    }

		person([string]$Name) {
			$this.SetName($Name)
		}
}

Vous définissez ensuite une classe enfant, teacher, par exemple, et essayez de créer un objet sans paramètres à partir de celle-ci, comme indiqué ci-dessous. Remarquez que PowerShell renvoie une erreur car un constructeur sans paramètres n’a pas été défini à l’intérieur de la classe teacher.

A constructor is not necessary in a child class if you’re only using it as a template. Alternatively, if you want to use the parent class as its own standalone class and as a parent class you can include constructors. But you have to make sure that the parent class has a constructor that matches the ones in the child classes.

Attributs des membres de classe

Tout comme les paramètres de commande PowerShell, les classes peuvent avoir des attributs de membre. Ces attributs modifient le comportement de chaque membre.

Membres masqués

Si vous utilisez un membre de classe à des fins internes uniquement et que vous ne souhaitez pas que l’utilisateur puisse le lire ou l’écrire, vous définissez un membre comme caché. Par exemple, peut-être avez-vous une méthode qui n’est utilisée que par d’autres méthodes. Il n’est pas nécessaire d’exposer cette méthode à l’utilisateur.

Pour définir un membre caché, utilisez l’attribut hidden comme indiqué ci-dessous.

class teacher {
    [int]hidden $EmployeeId
}

Maintenant, lorsque vous utilisez Get-Member pour inspecter tous les membres de l’objet, cette propriété n’apparaît pas.

Définir un membre de classe comme caché ne restreint pas l’accès à la valeur; cela la cache simplement de la vue. Vous ne devez pas cacher les propriétés pour stocker des données sensibles.

Membres statiques

Rappelez-vous plus tôt; ce tutoriel utilisait le terme « instancier » pour décrire la création d’un objet à partir d’une classe. Lorsque vous instanciez un objet, cet objet prend toutes les propriétés et méthodes définies par la classe. Mais ce n’est pas toujours le cas.

Parfois, vous n’avez pas besoin de la surcharge de l’instanciation d’un objet entier. Au lieu de cela, vous devez référencer rapidement un seul membre de classe. Dans ce cas, vous pouvez définir un membre de classe comme statique.

Tout comme avec l’attribut hidden, définissez un membre de classe comme statique en utilisant le mot-clé static comme indiqué ci-dessous.

class student {
	[int]static $MaxClassCount = 7
}

Contrairement aux membres de classe typiques, PowerShell ne crée pas de propriétés et de méthodes à partir de membres de classe statiques. Lorsque vous définissez un membre de classe comme statique, comme les membres cachés, il n’apparaît pas lorsque vous utilisez Get-Member.

Par exemple, peut-être souhaitez-vous associer des noms de cours universitaires à la classe student et définir le nombre maximum de cours universitaires qu’un étudiant peut suivre. Pour ce faire, vous créez un membre de tableau Classes et un membre MaxClassCount.

Étant donné que l’utilisateur a rarement besoin de modifier le membre MaxClassCount, vous décidez de le définir comme statique.

Enfin, vous créez une méthode AddClass() pour ajouter une classe à l’emploi du temps de l’étudiant, mais seulement si elle est inférieure à MaxClassCount.

class student {
    [string[]]$Classes = @()
    [int]static $MaxClassCount = 7
    
    [void]AddClass ([string]$Name) {
        if ($this.Classes.Count -lt [student]::MaxClassCount) {
            $this.Classes += $Name
        }
    }
}

Maintenant, lorsque vous tentez de créer un nouvel objet student et d’attribuer trop de cours universitaires, PowerShell n’attribuera que le nombre maximum, qui serait sept.

$student1 = [student]::new()
'PE','English','Math','History','Computer Science','French','Wood Working','Cooking' | ForEach-Object {
	$student1.AddClass($_)
}
$student1.Classes

Vous pouvez modifier les valeurs des membres statiques à tout moment. Par exemple, si vous souhaitez définir le membre MaxClassCount sur 5 au lieu de 7, vous changerez la valeur à l’aide de [student]::MaxClassCount = 5. Changer la valeur ne supprimera pas rétroactivement les cours qui dépassent la limite dans cet exemple.

Conclusion

Les classes PowerShell brouillent la frontière entre un langage de script et un langage de programmation. Les classes sont un excellent moyen de définir des relations d’objet, d’ajouter des moyens d’interagir avec des objets et de formater des objets qui ne seraient normalement possibles qu’en écrivant des fonctions spécialisées.