Poznámka:
Přístup k této stránce vyžaduje autorizaci. Můžete se zkusit přihlásit nebo změnit adresáře.
Přístup k této stránce vyžaduje autorizaci. Můžete zkusit změnit adresáře.
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>]
Examples
Příklad 1 – Minimální vlastnosti třídy
Vlastnosti ExampleProject1 třídy 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 zadané 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
Třída ExampleProject3 definuje vlastnost Size jako celé číslo, které musí být větší nebo rovno 0 a menší 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ž ExampleProject3 vytvoří instanci, Velikost výchozí hodnota 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 nastavená 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
Třída ExampleProject4 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
Vlastnost guid třídy ExampleProject5 má klíčové slovo hidden. Vlastnost Guid se nezobrazuje ve výchozím výstupu třídy ani 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
Třída ExampleProject6 definuje statickou 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
Třída ExampleProject7 definuje vlastnost Duration script v konstruktoru statické třídy pomocí rutiny Update-TypeData. Použití Update-TypeData nebo rutiny Add-Member je jediný způsob, jak definovat pokročilé vlastnosti pro třídy PowerShellu.
Vlastnost Duration vrátí hodnotu $null, pokud StartDate i EndDate vlastnosti jsou nastaveny a 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 ExampleProject7 třídy zahrnuje dobu trvání. Vzhledem k tomu, že StartDate a Vlastnosti EndDate nejsou nastaveny, je vlastnost Duration$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
Při správné nastavení vlastností vrátí vlastnost Duration časový rozsah představující dobu spuštění projektu.
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, jako je číslo, logická hodnota nebo výčet, vlastnost má výchozí hodnotu v závislosti na typu:
- Číselné typy, jako jsou celá čísla a čísla s plovoucí desetinou čárkou, se ve výchozím nastavení
0 - Logické hodnoty se ve výchozím nastavení
$false - Výčty se standardně
0, ani výčet nedefinuje popisek pro0.
Další informace o výchozích hodnotách v rozhraní .NET naleznete 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.
Tato definice například pro třídu ProjectTask definuje explicitní výchozí hodnotu pro vlastnost Guid a každému novému instanci přiřadí náhodný identifikátor GUID.
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 slova hidden.
Skryté vlastnosti třídy jsou:
- Nezahrnut do výchozího výstupu pro třídu.
- Není součástí seznamu členů třídy vrácených rutinou
Get-Member. Pokud chcete uGet-Memberzobrazit skryté vlastnosti, použijte parametr 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 naleznete v tématu about_Hidden.
Statické vlastnosti
Vlastnost můžete definovat jako patřící do samotné třídy místo instancí třídy deklarací vlastnosti pomocí klíčového slova 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é. Lze je přepsat na libovolnou platnou hodnotu, jak je definováno typem a atributy statické vlastnosti.
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 znovu nadefinovala vlastnost bez nastavení výchozí hodnoty. Pro DerivedClassD je hodnota Override, protože třída předefinovala vlastnost s tímto řetězcem jako výchozí hodnotou.
"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, hodnota statické vlastnosti pro odvozené třídy je stejná jako základní třída, protože neinfinují 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
Je-li StaticProperty přístup a upraven prostřednictvím DerivedClassA, změněná hodnota ovlivňuje všechny třídy s výjimkou DerivedClassD.
Další informace o dědičnosti tříd, včetně komplexního příkladu, naleznete 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ých atributech najdete v tématu about_Functions_Advanced_Parameters.
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
}
}
}
Spropitné
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, aby kód pro přidání členů do třídy byl spuštěn pouze jednou v relaci.
Pouze přidat vlastnosti do třídy v nestatické konstruktory, pokud není možné 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 AliasPropertyMemberType.
Například tato definice třídy OperablePair definuje dvě celočíselné vlastnosti x a y s aliasy LeftHandSide a 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 }
}
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 s ScriptPropertyMemberType.
Například tato definice třídy Rozpočet definuje Výdaje a Revenues vlastnosti jako pole čísel s plovoucí desetinou čárkou. Pomocí 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 vlastnost backing _taskCount.
V tomto příkladu třída ProjectSize definuje skrytou celočíselnou vlastnost s názvem _value. Definuje hodnotu jako ScriptProperty s vlastní logikou 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 nastavit vlastnost Value 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.
Alternativní ř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 ValidateArgumentsAttribute typ 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 pomocí
Update-TypeDatadefinujte viditelnou logiku getter a setter.Vlastnosti nemůžou použít atribut aliasu. Atribut se vztahuje pouze na parametry, rutiny a funkce.
Alternativní řešení: K definování aliasů v konstruktorech tříd použijte rutinu
Update-TypeData.Při převodu třídy PowerShellu na JSON pomocí rutiny
ConvertTo-Jsonobsahuje výstupní JSON všechny skryté vlastnosti a jejich hodnoty.Alternativní řešení: Žádné
Viz také
Spolupracujte s námi na GitHubu
Zdroj tohoto obsahu najdete na GitHubu, kde můžete také vytvářet a kontrolovat problémy a žádosti o přijetí změn. Další informace najdete v našem průvodci pro přispěvatele.
