about_Classes_Properties
Krátký popis
Popisuje, jak definovat vlastnosti pro třídy PowerShellu.
Dlouhý popis
Vlastnosti jsou členy třídy, která obsahuje data. Vlastnosti jsou deklarovány jako proměnné v oboru třídy. Vlastnost může být libovolného předdefinovaný typ nebo instance jiné třídy. Třídy mohou nula nebo více vlastností. Třídy nemají maximální počet vlastností.
Vlastnosti třídy můžou mít libovolný počet atributů, včetně skrytých a statických atributů. Každá definice vlastnosti musí obsahovat typ vlastnosti. Můžete definovat výchozí hodnotu vlastnosti.
Syntaxe
Vlastnosti třídy používají následující syntaxe:
Jednořádková syntaxe
[[<attribute>]...] [<property-type>] $<property-name> [= <default-value>]
Víceřádkové syntaxe
[[<attribute>]...]
[<property-type>]
$<property-name> [= <default-value>]
Příklady
Příklad 1 – Minimální vlastnosti třídy
Vlastnosti Třídy ExampleProject1 používají předdefinované typy bez jakýchkoli atributů nebo výchozích hodnot.
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
Výchozí hodnota vlastností Name a Assignee je $null , protože jsou zadány jako řetězce, což je typ odkazu. Ostatní vlastnosti mají výchozí hodnotu pro jejich definovaný typ, protože se jedná o vlastnosti typu hodnoty. Další informace o výchozích hodnotách vlastností naleznete v tématu Výchozí hodnoty vlastností.
Příklad 2 – Vlastnosti třídy s vlastními typy
Vlastnosti ExampleProject2 zahrnují vlastní výčet a třídu definovanou v PowerShellu před ExampleProject2 třídy.
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
Příklad 3 – vlastnost třídy s ověřovacím atributem
ExampleProject3 třída definuje Size vlastnost jako celé číslo, které musí být větší nebo rovno 0 a menší než nebo rovno 16. K omezení hodnoty používá atribut ValidateRange .
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
Když instance ExampleProject3 vytvoří instanci, výchozí hodnota Velikost je 0. Nastavení vlastnosti na hodnotu v platném rozsahu aktualizuje hodnotu.
$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
Pokud je velikost nastavena na neplatnou hodnotu mimo rozsah, PowerShell vyvolá výjimku a hodnota se nezmění.
$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
Příklad 4 – vlastnost třídy s explicitní výchozí hodnotou
ExampleProject4 třída výchozí hodnotu Pro StartDate vlastnost aktuální datum.
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
Příklad 5 – vlastnost Skryté třídy
Guid vlastnost ExampleProject5 třídy má hidden klíčové slovo. Vlastnost Guid se nezobrazuje ve výchozím výstupu pro třídu nebo v seznamu vlastností vrácených 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;}
Příklad 6 – Statická vlastnost třídy
ExampleProject6 třída definuje static Projects vlastnost jako seznam všech vytvořených projektů. Výchozí konstruktor pro třídu přidá novou instanci do seznamu projektů.
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
Příklad 7 – Definování vlastnosti v konstruktoru
ExampleProject7 třída definuje Duration script vlastnost v konstruktoru statické třídy s rutinouUpdate-TypeData. Použití nebo Add-Member rutiny Update-TypeData je jediný způsob, jak definovat pokročilé vlastnosti pro třídy PowerShellu.
Vlastnost Duration vrátí hodnotu $null , pokud nejsou nastaveny vlastnosti StartDate a EndDate a Hodnota StartDate je definována tak, aby byla dřívější než 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
Výchozí zobrazení instance Třídy ExampleProject7 zahrnuje dobu trvání. Vzhledem k tomu, že vlastnosti StartDate a EndDate nejsou nastaveny, je $nullvlastnost Duration .
$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
Při správné nastavení vlastností vrátí vlastnost Duration časový rozsah představující dobu, po které se projekt spustil.
Výchozí hodnoty vlastností
Každá vlastnost třídy má implicitní výchozí hodnotu v závislosti na typu vlastnosti.
Pokud je vlastnost typu odkazu, jako je řetězec nebo objekt, implicitní výchozí hodnota je $null. Pokud je vlastnost typ hodnoty, například číslo, logická hodnota nebo výčet, má vlastnost výchozí hodnotu v závislosti na typu:
- Číselné typy, jako jsou celá čísla a čísla s plovoucí desetinou čárkou, mají výchozí hodnotu
0 - Výchozí logické hodnoty
$false - Výčty mají výchozí hodnotu
0, ani výčet nedefinuje popisek pro0.
Další informace o výchozích hodnotách v .NET najdete v tématu Výchozí hodnoty typů jazyka C# (referenční dokumentace jazyka C#).
Chcete-li definovat explicitní výchozí hodnotu vlastnosti, deklarujte vlastnost s přiřazením výchozí hodnoty.
Například tato definice pro ProjectTask třída definuje explicitní výchozí hodnotu pro Guid vlastnost, přiřazení náhodného GUID ke každé nové instanci.
class ProjectTask {
[string] $Name
[string] $Description
[string] $Guid = (New-Guid).Guid
}
[ProjectTask]::new()
Name Description Guid
---- ----------- ----
aa96350c-358d-465c-96d1-a49949219eec
Skryté a statické vlastnosti můžou mít také výchozí hodnoty.
Skryté vlastnosti
Vlastnosti třídy můžete skrýt deklarováním pomocí klíčového hidden slova.
Skryté vlastnosti třídy jsou:
- Nezahrnut do výchozího výstupu pro třídu.
- Součástí seznamu členů třídy vrácených rutinou
Get-Membernení. Pokud chcete zobrazit skryté vlastnosti pomocíGet-Memberparametru Force . - Nezobrazuje se v dokončování tabulátoru nebo IntelliSense, pokud nedojde k dokončení ve třídě, která definuje skrytou vlastnost.
- Veřejné členy třídy. K nim je možné přistupovat a upravovat. Skrytí vlastnosti ho neudělá jako soukromou. Skryje vlastnost, jak je popsáno v předchozích bodech.
Další informace o klíčovém slově hidden najdete v tématu about_Hidden.
Statické vlastnosti
Vlastnost můžete definovat jako patřící samotné třídě namísto instancí třídy deklarováním vlastnosti s klíčovým slovem static . Vlastnosti statické třídy:
- Jsou vždy k dispozici nezávisle na vytváření instancí třídy.
- Sdílí se napříč všemi instancemi třídy.
- Jsou vždy k dispozici.
- Je možné je upravit. Statické vlastnosti je možné aktualizovat. Ve výchozím nastavení nejsou neměnné.
- Živě pro celou relaci.
Důležité
Statické vlastnosti pro třídy definované v PowerShellu nejsou neměnné. Mohou
Odvozené vlastnosti třídy
Když třída je odvozena od základní třídy, dědí vlastnosti základní třídy. Všechny vlastnosti definované v základní třídě, včetně skrytých vlastností, jsou k dispozici v odvozené třídě.
Odvozená třída může přepsat zděděnou vlastnost tím, že ji předefinuje v definici třídy. Vlastnost odvozené třídy používá redefinovaný typ a výchozí hodnotu, pokud existuje. Pokud zděděná vlastnost definovala výchozí hodnotu a předdefinovaná vlastnost ne, zděděná vlastnost nemá žádnou výchozí hodnotu.
Pokud odvozená třída nepřepíše statickou vlastnost, přístup ke statické vlastnosti prostřednictvím odvozené třídy přistupuje ke statické vlastnosti základní třídy. Úprava hodnoty vlastnosti prostřednictvím odvozené třídy upraví hodnotu základní třídy. Všechny ostatní odvozené třídy, které nepřepíší statickou vlastnost, také používá hodnotu vlastnosti základní třídy. Aktualizace hodnoty zděděné statické vlastnosti ve třídě, která nepřepíše vlastnost, může mít nezamýšlené účinky pro třídy odvozené ze stejné základní třídy.
Následující příklad ukazuje chování statických vlastností a vlastností instance u odvozených tříd.
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 pro DerivedClassC je prázdný řetězec, protože třída předefinovala vlastnost bez nastavení výchozí hodnoty. Pro DerivedClassD hodnota je Override důvodem, že třída redefinovala vlastnost s tímto řetězcem jako výchozí hodnotu.
"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
S výjimkou DerivedClassD je hodnota statické vlastnosti pro odvozené třídy stejná jako základní třída, protože nepřeefinují vlastnost. To platí i pro DerivedClassC, který dědí z DerivedClassB místo přímo z 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
Pokud je staticProperty přístup a upraven prostřednictvím DerivedClassA, změněná hodnota ovlivní všechny třídy s výjimkou DerivedClassD.
Další informace o dědičnosti tříd, včetně komplexního příkladu, najdete v tématu about_Classes_Inheritance.
Použití atributů vlastností
PowerShell obsahuje několik tříd atributů, které můžete použít k vylepšení informací o datovém typu a ověření dat přiřazených k vlastnosti. Ověřovací atributy umožňují otestovat, že hodnoty zadané vlastnostmi splňují definované požadavky. Ověření se aktivuje v okamžiku, kdy je hodnota přiřazena.
Další informace o dostupnýchatributch about_Functions_Advanced_Parameters ch
Definování vlastností instance pomocí Update-TypeData
Kromě deklarování vlastností přímo v definici třídy můžete definovat vlastnosti pro instance třídy ve statickém konstruktoru pomocí rutiny Update-TypeData .
Tento fragment kódu použijte jako výchozí bod pro vzor. Podle potřeby nahraďte zástupný text v úhlových závorkách.
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
}
}
}
Tip
Rutina Add-Member může přidat vlastnosti a metody do třídy v nestatického konstruktoru, ale rutina se spustí při každém zavolání konstruktoru. Použití Update-TypeData ve statickém konstruktoru zajišťuje, že kód pro přidání členů do třídy musí běžet pouze jednou v relaci.
Pouze přidat vlastnosti do třídy v nestatické konstruktory, pokud nelze definovat pomocí Update-TypeData, jako jsou vlastnosti jen pro čtení.
Definování vlastností aliasu
Atribut Alias nemá žádný vliv při použití na deklaraci vlastnosti třídy. PowerShell tento atribut používá pouze k definování aliasů pro názvy rutin, parametrů a funkcí.
Chcete-li definovat alias pro vlastnost třídy, použijte Update-TypeData s AliasProperty MemberType.
Tato definice operablePair třídy například definuje dvě celočíselné vlastnosti x a y s aliasy LeftHandSide a RightHandSide v uvedeném pořadí.
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 }
}
S definovanými aliasy mají uživatelé přístup k vlastnostem s některým názvem.
$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
Definování počítaných vlastností
Chcete-li definovat vlastnost, která odkazuje na hodnoty jiných vlastností, použijte rutinu Update-TypeData ScriptProperty s MemberType.
Tato definice třídy Rozpočet například definuje vlastnosti Výdaje a Výnosy jako pole čísel s plovoucí desetinou čárkou. Pomocí této rutiny Update-TypeData definuje počítané vlastnosti pro celkové výdaje, celkové výnosy a čistý příjem.
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}
Definování vlastností pomocí vlastní logiky get a set
Vlastnosti třídy PowerShellu nemůžou přímo definovat vlastní logiku getter a setter. Tuto funkci můžete odhadnout definováním backing vlastnosti s klíčovým slovem hidden a použitím Update-TypeData definovat viditelnou vlastnost s vlastní logikou pro získání a nastavení hodnoty.
Podle konvence definujte skrytý název backing vlastnosti s předponou podtržítka a použijte velbloudí velikostí. Například místo TaskCountpojmenujte skrytou záložní vlastnost _taskCount.
V tomto příkladu třída ProjectSize definuje skrytou celočíselnou vlastnost s názvem _value. Definuje hodnotu jako vlastní logiku ScriptProperty pro získání a nastavení vlastnosti _value. Setter scriptblock zpracovává převod řetězcové reprezentace projektu na správnou velikost.
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
}
}
S definovaným vlastním getterem a setter můžete vlastnost Value nastavit jako celé číslo nebo řetězec.
$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
Omezení
Vlastnosti třídy PowerShellu mají následující omezení:
Statické vlastnosti jsou vždy proměnlivé. Třídy PowerShellu nemůžou definovat neměnné statické vlastnosti.
Řešení: Žádné.
Vlastnosti nemohou použít atribut ValidateScript , protože argumenty atributu vlastnosti třídy musí být konstanty.
Alternativní řešení: Definujte třídu, která dědí z typu ValidateArgumentsAttribute a místo toho tento atribut použijte.
Přímo deklarované vlastnosti nemohou definovat vlastní implementace getter a setter.
Alternativní řešení: Definujte skrytou vlastnost a použijte
Update-TypeDatak definování viditelné logiky getter a setter.Vlastnosti nemůžou použít atribut Alias . Atribut se vztahuje pouze na parametry, rutiny a funkce.
Alternativní řešení: Pomocí rutiny
Update-TypeDatadefinujte aliasy v konstruktorech tříd.Při převodu třídy PowerShellu
ConvertTo-Jsonna JSON pomocí rutiny obsahuje výstupní JSON všechny skryté vlastnosti a jejich hodnoty.Řešení: Žádné
