about_Classes_Properties
Description courte
Décrit comment définir des propriétés pour les classes PowerShell.
Description longue
Les propriétés sont membres de la classe qui contiennent des données. Les propriétés sont déclarées en tant que variables dans l’étendue de la classe. Une propriété peut être de n’importe quel type intégré ou d’une instance d’une autre classe. Les classes peuvent zéro ou plusieurs propriétés. Les classes n’ont pas de nombre maximal de propriétés.
Les propriétés de classe peuvent avoir n’importe quel nombre d’attributs, y compris les attributs masqués et statiques . Chaque définition de propriété doit inclure un type pour la propriété. Vous pouvez définir une valeur par défaut pour une propriété.
Syntaxe
Les propriétés de classe utilisent les syntaxes suivantes :
Syntaxe d’une ligne
[[<attribute>]...] [<property-type>] $<property-name> [= <default-value>]
Syntaxe multiligne
[[<attribute>]...]
[<property-type>]
$<property-name> [= <default-value>]
Exemples
Exemple 1 - Propriétés de classe minimales
Les propriétés de la classe ExampleProject1 utilisent des types intégrés sans attributs ni valeurs par défaut.
class ExampleProject1 {
[string] $Name
[int] $Size
[bool] $Completed
[string] $Assignee
[datetime] $StartDate
[datetime] $EndDate
[datetime] $DueDate
}
[ExampleProject1]::new()
$null -eq ([ExampleProject1]::new()).Name
Name :
Size : 0
Completed : False
StartDate : 1/1/0001 12:00:00 AM
EndDate : 1/1/0001 12:00:00 AM
DueDate : 1/1/0001 12:00:00 AM
True
La valeur par défaut des propriétés Name et Assignee est $null due au fait qu’elles sont typées sous forme de chaînes, qui est un type de référence. Les autres propriétés ont la valeur par défaut pour leur type défini, car elles sont des propriétés de type valeur. Pour plus d’informations sur les valeurs par défaut des propriétés, consultez Valeurs de propriété par défaut.
Exemple 2 - Propriétés de classe avec des types personnalisés
Les propriétés de ExampleProject2 incluent une énumération et une classe personnalisées définies dans PowerShell avant la classe ExampleProject2 .
enum ProjectState {
NotTriaged
ReadyForWork
Committed
Blocked
InProgress
Done
}
class ProjectAssignee {
[string] $DisplayName
[string] $UserName
[string] ToString() {
return "$($this.DisplayName) ($($this.UserName))"
}
}
class ExampleProject2 {
[string] $Name
[int] $Size
[ProjectState] $State
[ProjectAssignee] $Assignee
[datetime] $StartDate
[datetime] $EndDate
[datetime] $DueDate
}
[ExampleProject2]@{
Name = 'Class Property Documentation'
Size = 8
State = 'InProgress'
Assignee = @{
DisplayName = 'Mikey Lombardi'
UserName = 'michaeltlombardi'
}
StartDate = '2023-10-23'
DueDate = '2023-10-27'
}
Name : Class Property Documentation
Size : 8
State : InProgress
Assignee : Mikey Lombardi (michaeltlombardi)
StartDate : 10/23/2023 12:00:00 AM
EndDate : 1/1/0001 12:00:00 AM
DueDate : 10/27/2023 12:00:00 AM
Exemple 3 - Propriété de classe avec un attribut de validation
La classe ExampleProject3 définit la propriété Size en tant qu’entier qui doit être supérieur ou égal à 0 et inférieur ou égal à 16. Il utilise l’attribut ValidateRange pour limiter la valeur.
class ExampleProject3 {
[string] $Name
[ValidateRange(0, 16)] [int] $Size
[bool] $Completed
[string] $Assignee
[datetime] $StartDate
[datetime] $EndDate
[datetime] $DueDate
}
$project = [ExampleProject3]::new()
$project
Name :
Size : 0
Completed : False
Assignee :
StartDate : 1/1/0001 12:00:00 AM
EndDate : 1/1/0001 12:00:00 AM
DueDate : 1/1/0001 12:00:00 AM
Lorsque ExampleProject3 instancie, la taille par défaut est 0. La définition de la propriété sur une valeur dans la plage valide met à jour la valeur.
$project.Size = 8
$project
Name :
Size : 8
Completed : False
Assignee :
StartDate : 1/1/0001 12:00:00 AM
EndDate : 1/1/0001 12:00:00 AM
DueDate : 1/1/0001 12:00:00 AM
Lorsque la taille est définie sur une valeur non valide en dehors de la plage, PowerShell déclenche une exception et la valeur n’est pas modifiée.
$project.Size = 32
$project.Size = -1
$project
SetValueInvocationException:
Line |
1 | $project.Size = 32
| ~~~~~~~~~~~~~~~~~~
| Exception setting "Size": "The 32 argument is greater than the
| maximum allowed range of 16. Supply an argument that is less than
| or equal to 16 and then try the command again."
SetValueInvocationException:
Line |
2 | $project.Size = -1
| ~~~~~~~~~~~~~~~~~~
| Exception setting "Size": "The -1 argument is less than the minimum
| allowed range of 0. Supply an argument that is greater than or
| equal to 0 and then try the command again."
Name :
Size : 8
Completed : False
Assignee :
StartDate : 1/1/0001 12:00:00 AM
EndDate : 1/1/0001 12:00:00 AM
DueDate : 1/1/0001 12:00:00 AM
Exemple 4 - Propriété de classe avec une valeur par défaut explicite
La classe ExampleProject4 affecte par défaut la valeur de la propriété StartDate à la date actuelle.
class ExampleProject4 {
[string] $Name
[int] $Size
[bool] $Completed
[string] $Assignee
[datetime] $StartDate = (Get-Date).Date
[datetime] $EndDate
[datetime] $DueDate
}
[ExampleProject4]::new()
[ExampleProject4]::new().StartDate -eq (Get-Date).Date
Name :
Size : 0
Completed : False
Assignee :
StartDate : 10/23/2023 12:00:00 AM
EndDate : 1/1/0001 12:00:00 AM
DueDate : 1/1/0001 12:00:00 AM
True
Exemple 5 - Propriété de classe masquée
La propriété Guid de la classe ExampleProject5 a le hidden mot clé. La propriété Guid ne s’affiche pas dans la sortie par défaut de la classe ou dans la liste des propriétés retournées par Get-Member.
class ExampleProject5 {
[string] $Name
[int] $Size
[bool] $Completed
[string] $Assignee
[datetime] $StartDate
[datetime] $EndDate
[datetime] $DueDate
hidden [string] $Guid = (New-Guid).Guid
}
$project = [ExampleProject5]::new()
"Project GUID: $($project.Guid)"
$project
$project | Get-Member -MemberType Properties | Format-Table
Project GUID: c72cef84-057c-4649-8940-13490dcf72f0
Name :
Size : 0
Completed : False
Assignee :
StartDate : 1/1/0001 12:00:00 AM
EndDate : 1/1/0001 12:00:00 AM
DueDate : 1/1/0001 12:00:00 AM
TypeName: ExampleProject5
Name MemberType Definition
---- ---------- ----------
Assignee Property string Assignee {get;set;}
Completed Property bool Completed {get;set;}
DueDate Property datetime DueDate {get;set;}
EndDate Property datetime EndDate {get;set;}
Name Property string Name {get;set;}
Size Property int Size {get;set;}
StartDate Property datetime StartDate {get;set;}
Exemple 6 - Propriété de classe statique
La classe ExampleProject6 définit la propriété Projects statique comme liste de tous les projets créés. Le constructeur par défaut de la classe ajoute la nouvelle instance à la liste des projets.
class ExampleProject6 {
[string] $Name
[int] $Size
[bool] $Completed
[string] $Assignee
[datetime] $StartDate
[datetime] $EndDate
[datetime] $DueDate
hidden [string] $Guid = (New-Guid).Guid
static [ExampleProject6[]] $Projects = @()
ExampleProject6() {
[ExampleProject6]::Projects += $this
}
}
"Project Count: $([ExampleProject6]::Projects.Count)"
$project1 = [ExampleProject6]@{ Name = 'Project_1' }
$project2 = [ExampleProject6]@{ Name = 'Project_2' }
[ExampleProject6]::Projects | Select-Object -Property Name, Guid
Project Count: 0
Name Guid
---- ----
Project_1 75e7c8a0-f8d1-433a-a5be-fd7249494694
Project_2 6c501be4-e68c-4df5-8fce-e49dd8366afe
Exemple 7 : Définition d’une propriété dans le constructeur
La classe ExampleProject7 définit la propriété de script Duration dans le constructeur de classe statique avec l’applet de Update-TypeData commande. L’utilisation de Add-Member l’applet de commande ou de l’applet Update-TypeData de commande est la seule façon de définir des propriétés avancées pour les classes PowerShell.
La propriété Duration retourne une valeur de $null sauf si les propriétés StartDate et EndDate sont définies et StartDate sont définies comme étant antérieures à EndDate.
class ExampleProject7 {
[string] $Name
[int] $Size
[bool] $Completed
[string] $Assignee
[datetime] $StartDate
[datetime] $EndDate
[datetime] $DueDate
static [hashtable[]] $MemberDefinitions = @(
@{
MemberName = 'Duration'
MemberType = 'ScriptProperty'
Value = {
[datetime]$UnsetDate = 0
$StartNotSet = $this.StartDate -eq $UnsetDate
$EndNotSet = $this.EndDate -eq $UnsetDate
$StartAfterEnd = $this.StartDate -gt $this.EndDate
if ($StartNotSet -or $EndNotSet -or $StartAfterEnd) {
return $null
}
return $this.EndDate - $this.StartDate
}
}
)
static ExampleProject7() {
$TypeName = [ExampleProject7].Name
foreach ($Definition in [ExampleProject7]::MemberDefinitions) {
Update-TypeData -TypeName $TypeName @Definition
}
}
ExampleProject7() {}
ExampleProject7([string]$Name) {
$this.Name = $Name
}
}
$Project = [ExampleProject7]::new()
$Project
$null -eq $Project.Duration
Duration :
Name :
Size : 0
Completed : False
Assignee :
StartDate : 1/1/0001 12:00:00 AM
EndDate : 1/1/0001 12:00:00 AM
DueDate : 1/1/0001 12:00:00 AM
True
La vue par défaut d’une instance de la classe ExampleProject7 inclut la durée. Étant donné que les propriétés StartDate et EndDate ne sont pas définies, la propriété Duration est $null.
$Project.StartDate = '2023-01-01'
$Project.EndDate = '2023-01-08'
$Project
Duration : 7.00:00:00
Name :
Size : 0
Completed : False
Assignee :
StartDate : 1/1/2023 12:00:00 AM
EndDate : 1/8/2023 12:00:00 AM
DueDate : 1/1/0001 12:00:00 AM
Avec les propriétés définies correctement, la propriété Duration retourne un intervalle de temps représentant la durée pendant laquelle le projet a été exécuté.
Valeurs de propriété par défaut
Chaque propriété de classe a une valeur par défaut implicite en fonction du type de la propriété.
Si une propriété est un type référence, comme une chaîne ou un objet, la valeur par défaut implicite est $null. Si une propriété est un type valeur, comme un nombre, une valeur booléenne ou une énumération, la propriété a une valeur par défaut en fonction du type :
- Types numériques, tels que les entiers et les nombres à virgule flottante, par défaut
0 - Valeurs booléennes par défaut
$false - Les énumérations par défaut sont
0, même l’énumération ne définit pas d’étiquette pour0.
Pour plus d’informations sur les valeurs par défaut dans .NET, consultez Valeurs par défaut des types C# (référence C#).
Pour définir une valeur par défaut explicite pour une propriété, déclarez la propriété avec une affectation à la valeur par défaut.
Par exemple, cette définition pour la classe ProjectTask définit une valeur par défaut explicite pour la propriété Guid , en affectant un GUID aléatoire à chaque nouvelle instance.
class ProjectTask {
[string] $Name
[string] $Description
[string] $Guid = (New-Guid).Guid
}
[ProjectTask]::new()
Name Description Guid
---- ----------- ----
aa96350c-358d-465c-96d1-a49949219eec
Les propriétés masquées et statiques peuvent également avoir des valeurs par défaut.
Propriétés masquées
Vous pouvez masquer les propriétés d’une classe en les déclarant avec le hidden mot clé.
Les propriétés de classe masquées sont les suivantes :
- Non inclus dans la sortie par défaut de la classe.
- Non inclus dans la liste des membres de classe retournés par l’applet de
Get-Membercommande. Pour afficher les propriétés masquées avecGet-Member, utilisez le paramètre Force . - Non affiché dans la saisie semi-automatique de tabulation ou IntelliSense, sauf si la saisie semi-automatique se produit dans la classe qui définit la propriété masquée.
- Membres publics de la classe. Ils sont accessibles et modifiés. Masquage d’une propriété ne le rend pas privé. Elle masque uniquement la propriété comme décrit dans les points précédents.
Pour plus d’informations sur le hidden mot clé, consultez about_Hidden.
Propriétés statiques
Vous pouvez définir une propriété comme appartenant à la classe elle-même au lieu d’instances de la classe en déclarant la propriété avec le static mot clé. Propriétés de classe statique :
- Sont toujours disponibles, indépendamment de l’instanciation de classe.
- Sont partagés entre toutes les instances de la classe.
- Sont toujours disponibles.
- Sont modifiables. Les propriétés statiques peuvent être mises à jour. Ils ne sont pas immuables par défaut.
- Live pour l’ensemble de la session.
Important
Les propriétés statiques pour les classes définies dans PowerShell ne sont pas immuables. Ils peuvent
Propriétés de classe dérivées
Lorsqu’une classe dérive d’une classe de base, elle hérite des propriétés de la classe de base. Toutes les propriétés définies sur la classe de base, y compris les propriétés masquées, sont disponibles sur la classe dérivée.
Une classe dérivée peut remplacer une propriété héritée en la redéfinissant dans la définition de classe. La propriété de la classe dérivée utilise le type redéfini et la valeur par défaut, le cas échéant. Si la propriété héritée a défini une valeur par défaut et que la propriété redéfinie ne le fait pas, la propriété héritée n’a pas de valeur par défaut.
Si une classe dérivée ne remplace pas une propriété statique, l’accès à la propriété statique via la classe dérivée accède à la propriété statique de la classe de base. La modification de la valeur de propriété par le biais de la classe dérivée modifie la valeur sur la classe de base. Toute autre classe dérivée qui ne remplace pas la propriété statique utilise également la valeur de la propriété sur la classe de base. La mise à jour de la valeur d’une propriété statique héritée dans une classe qui ne remplace pas la propriété peut avoir des effets inattendus pour les classes dérivées de la même classe de base.
L’exemple suivant montre le comportement des propriétés statiques et d’instance sur les classes dérivées.
class BaseClass {
static [string] $StaticProperty = 'Static'
[string] $InstanceProperty = 'Instance'
}
class DerivedClassA : BaseClass {}
class DerivedClassB : BaseClass {}
class DerivedClassC : DerivedClassB {
[string] $InstanceProperty
}
class DerivedClassD : BaseClass {
static [string] $StaticProperty = 'Override'
[string] $InstanceProperty = 'Override'
}
"Base instance => $([BaseClass]::new().InstanceProperty)"
"Derived instance A => $([DerivedClassA]::new().InstanceProperty)"
"Derived instance B => $([DerivedClassB]::new().InstanceProperty)"
"Derived instance C => $([DerivedClassC]::new().InstanceProperty)"
"Derived instance D => $([DerivedClassD]::new().InstanceProperty)"
Base instance => Instance
Derived instance A => Instance
Derived instance B => Instance
Derived instance C =>
Derived instance D => Override
InstanceProperty pour DerivedClassC est une chaîne vide, car la classe a redéfini la propriété sans définir de valeur par défaut. Pour DerivedClassD , la valeur est Override parce que la classe a redéfini la propriété avec cette chaîne comme valeur par défaut.
"Base static => $([BaseClass]::StaticProperty)"
"Derived static A => $([DerivedClassA]::StaticProperty)"
"Derived static B => $([DerivedClassB]::StaticProperty)"
"Derived static C => $([DerivedClassC]::StaticProperty)"
"Derived static D => $([DerivedClassD]::StaticProperty)"
Base static => Static
Derived static A => Static
Derived static B => Static
Derived static C => Static
Derived static D => Override
À l’exception de DerivedClassD, la valeur de la propriété statique pour les classes dérivées est la même que la classe de base, car elle ne redéfinit pas la propriété. Cela s’applique même à DerivedClassC, qui hérite de DerivedClassB au lieu de directement de BaseClass.
[DerivedClassA]::StaticProperty = 'Updated from A'
"Base static => $([BaseClass]::StaticProperty)"
"Derived static A => $([DerivedClassA]::StaticProperty)"
"Derived static B => $([DerivedClassB]::StaticProperty)"
"Derived static C => $([DerivedClassC]::StaticProperty)"
"Derived static D => $([DerivedClassD]::StaticProperty)"
Base static => Updated from A
Derived static A => Updated from A
Derived static B => Updated from A
Derived static C => Updated from A
Derived static D => Override
Lorsque StaticProperty est accessible et modifié via DerivedClassA, la valeur modifiée affecte chaque classe, à l’exception de DerivedClassD.
Pour plus d’informations sur l’héritage de classes, notamment un exemple complet, consultez about_Classes_Inheritance.
Utilisation des attributs de propriété
PowerShell inclut plusieurs classes d’attributs que vous pouvez utiliser pour améliorer les informations de type de données et valider les données affectées à une propriété. Les attributs de validation vous permettent de tester que les valeurs données aux propriétés répondent aux exigences définies. La validation est déclenchée au moment où la valeur est affectée.
Pour plus d’informations sur les attributs disponibles, consultez about_Functions_Advanced_Parameters.
Définition des propriétés d’instance avec Update-TypeData
Au-delà de déclarer des propriétés directement dans la définition de classe, vous pouvez définir des propriétés pour les instances d’une classe dans le constructeur statique à l’aide de l’applet Update-TypeData de commande.
Utilisez cet extrait de code comme point de départ pour le modèle. Remplacez le texte de l’espace réservé entre crochets angle en fonction des besoins.
class <ClassName> {
static [hashtable[]] $MemberDefinitions = @(
@{
MemberName = '<PropertyName>'
MemberType = '<PropertyType>'
Value = <ValueDefinition>
}
)
static <ClassName>() {
$TypeName = [<ClassName>].Name
foreach ($Definition in [<ClassName>]::MemberDefinitions) {
Update-TypeData -TypeName $TypeName @Definition
}
}
}
Conseil
L’applet Add-Member de commande peut ajouter des propriétés et des méthodes à une classe dans des constructeurs non statiques, mais l’applet de commande est exécutée chaque fois que le constructeur est appelé. L’utilisation Update-TypeData dans le constructeur statique garantit que le code permettant d’ajouter les membres à la classe ne doit s’exécuter qu’une seule fois dans une session.
Ajoutez uniquement des propriétés à la classe dans des constructeurs non statiques lorsqu’elles ne peuvent pas être définies avec Update-TypeData, comme les propriétés en lecture seule.
Définition des propriétés d’alias
L’attribut Alias n’a aucun effet lorsqu’il est utilisé sur une déclaration de propriété de classe. PowerShell utilise uniquement cet attribut pour définir des alias pour les noms d’applet de commande, de paramètre et de fonction.
Pour définir un alias pour une propriété de classe, utilisez Update-TypeData le AliasProperty MemberType.
Par exemple, cette définition de la classe OperablePair définit respectivement deux propriétés entières x et y avec les alias LeftHandSide et RightHandSide.
class OperablePair {
[int] $x
[int] $y
static [hashtable[]] $MemberDefinitions = @(
@{
MemberType = 'AliasProperty'
MemberName = 'LeftHandSide'
Value = 'x'
}
@{
MemberType = 'AliasProperty'
MemberName = 'RightHandSide'
Value = 'y'
}
)
static OperablePair() {
$TypeName = [OperablePair].Name
foreach ($Definition in [OperablePair]::MemberDefinitions) {
Update-TypeData -TypeName $TypeName @Definition
}
}
OperablePair() {}
OperablePair([int]$x, [int]$y) {
$this.x = $x
$this.y = $y
}
# Math methods for the pair of values
[int] GetSum() { return $this.x + $this.y }
[int] GetProduct() { return $this.x * $this.y }
[int] GetDifference() { return $this.x - $this.y }
[float] GetQuotient() { return $this.x / $this.y }
[int] GetModulus() { return $this.x % $this.y }
}
Avec les alias définis, les utilisateurs peuvent accéder aux propriétés avec l’un ou l’autre nom.
$pair = [OperablePair]@{ x = 8 ; RightHandSide = 3 }
"$($pair.x) % $($pair.y) = $($pair.GetModulus())"
$pair.LeftHandSide = 3
$pair.RightHandSide = 2
"$($pair.x) x $($pair.y) = $($pair.GetProduct())"
8 % 3 = 2
3 x 2 = 6
Définition des propriétés calculées
Pour définir une propriété qui référence les valeurs d’autres propriétés, utilisez l’applet Update-TypeData de commande avec ScriptProperty MemberType.
Par exemple, cette définition de la classe Budget définit les propriétés Expenses and Revenues comme des tableaux de nombres à virgule flottante. Il utilise l’applet Update-TypeData de commande pour définir des propriétés calculées pour les dépenses totales, le chiffre d’affaires total et le revenu net.
class Budget {
[float[]] $Expenses
[float[]] $Revenues
static [hashtable[]] $MemberDefinitions = @(
@{
MemberType = 'ScriptProperty'
MemberName = 'TotalExpenses'
Value = { ($this.Expenses | Measure-Object -Sum).Sum }
}
@{
MemberType = 'ScriptProperty'
MemberName = 'TotalRevenues'
Value = { ($this.Revenues | Measure-Object -Sum).Sum }
}
@{
MemberType = 'ScriptProperty'
MemberName = 'NetIncome'
Value = { $this.TotalRevenues - $this.TotalExpenses }
}
)
static Budget() {
$TypeName = [Budget].Name
foreach ($Definition in [Budget]::MemberDefinitions) {
Update-TypeData -TypeName $TypeName @Definition
}
}
Budget() {}
Budget($Expenses, $Revenues) {
$this.Expenses = $Expenses
$this.Revenues = $Revenues
}
}
[Budget]::new()
[Budget]@{
Expenses = @(2500, 1931, 3700)
Revenues = @(2400, 2100, 4150)
}
TotalExpenses : 0
TotalRevenues : 0
NetIncome : 0
Expenses :
Revenues :
TotalExpenses : 8131
TotalRevenues : 8650
NetIncome : 519
Expenses : {2500, 1931, 3700}
Revenues : {2400, 2100, 4150}
Définition de propriétés avec une logique d’obtention et de définition personnalisée
Les propriétés de classe PowerShell ne peuvent pas définir directement la logique getter et setter personnalisée. Vous pouvez estimer cette fonctionnalité en définissant une propriété de stockage avec le hidden mot clé et en utilisant Update-TypeData pour définir une propriété visible avec une logique personnalisée pour obtenir et définir la valeur.
Par convention, définissez le nom de la propriété de stockage masquée avec un préfixe de soulignement et utilisez la casse chameau. Par exemple, au lieu de TaskCount, nommez la propriété _taskCountde stockage masquée.
Dans cet exemple, la classe ProjectSize définit une propriété entière masquée nommée _value. Il définit La valeur comme une ScriptProperty logique personnalisée pour obtenir et définir la propriété _value . Le scriptblock setter gère la conversion de la représentation sous forme de chaîne du projet en taille correcte.
class ProjectSize {
hidden [ValidateSet(0, 1, 2, 3)] [int] $_value
static [hashtable[]] $MemberDefinitions = @(
@{
MemberType = 'ScriptProperty'
MemberName = 'Value'
Value = { $this._value } # Getter
SecondValue = { # Setter
$ProposedValue = $args[0]
if ($ProposedValue -is [string]) {
switch ($ProposedValue) {
'Small' { $this._value = 1 ; break }
'Medium' { $this._value = 2 ; break }
'Large' { $this._value = 3 ; break }
default { throw "Unknown size '$ProposedValue'" }
}
} else {
$this._value = $ProposedValue
}
}
}
)
static ProjectSize() {
$TypeName = [ProjectSize].Name
foreach ($Definition in [ProjectSize]::MemberDefinitions) {
Update-TypeData -TypeName $TypeName @Definition
}
}
ProjectSize() {}
ProjectSize([int]$Size) { $this.Value = $Size }
ProjectSize([string]$Size) { $this.Value = $Size }
[string] ToString() {
$Output = switch ($this._value) {
1 { 'Small' }
2 { 'Medium' }
3 { 'Large' }
default { 'Undefined' }
}
return $Output
}
}
Avec le getter personnalisé et setter défini, vous pouvez définir la propriété Value en tant qu’entier ou chaîne.
$size = [ProjectSize]::new()
"The initial size is: $($size._value), $size"
$size.Value = 1
"The defined size is: $($size._value), $size"
$Size.Value += 1
"The updated size is: $($size._value), $size"
$Size.Value = 'Large'
"The final size is: $($size._value), $size"
The initial size is: 0, Undefined
The defined size is: 1, Small
The updated size is: 2, Medium
The final size is: 3, Large
Limites
Les propriétés de classe PowerShell présentent les limitations suivantes :
Les propriétés statiques sont toujours mutables. Les classes PowerShell ne peuvent pas définir de propriétés statiques immuables.
Solution de contournement : aucune.
Les propriétés ne peuvent pas utiliser l’attribut ValidateScript , car les arguments d’attribut de propriété de classe doivent être des constantes.
Solution de contournement : Définissez une classe qui hérite du type ValidateArgumentsAttribute et utilisez cet attribut à la place.
Les propriétés déclarées directement ne peuvent pas définir d’implémentations getter et setter personnalisées.
Solution de contournement : définissez une propriété masquée et utilisez-la
Update-TypeDatapour définir la logique getter et setter visibles.Les propriétés ne peuvent pas utiliser l’attribut Alias . L’attribut s’applique uniquement aux paramètres, aux applets de commande et aux fonctions.
Solution de contournement : utilisez l’applet
Update-TypeDatade commande pour définir des alias dans les constructeurs de classe.Lorsqu’une classe PowerShell est convertie en JSON avec l’applet
ConvertTo-Jsonde commande, le code JSON de sortie inclut toutes les propriétés masquées et leurs valeurs.Solution de contournement : aucune
