about_Classes_Properties
Korte beschrijving
Hierin wordt beschreven hoe u eigenschappen voor PowerShell-klassen definieert.
Lange beschrijving
Eigenschappen zijn leden van de klasse die gegevens bevatten. Eigenschappen worden gedeclareerd als variabelen in het klassebereik. Een eigenschap kan van elk ingebouwd type zijn of een exemplaar van een andere klasse. Klassen kunnen nul of meer eigenschappen hebben. Klassen hebben geen maximumaantal eigenschappen.
Klasse-eigenschappen kunnen een willekeurig aantal kenmerken hebben, inclusief de verborgen en statische kenmerken. Elke eigenschapsdefinitie moet een type voor de eigenschap bevatten. U kunt een standaardwaarde voor een eigenschap definiëren.
Syntax
Klasse-eigenschappen gebruiken de volgende syntaxis:
Syntaxis van één regel
[[<attribute>]...] [<property-type>] $<property-name> [= <default-value>]
Syntaxis van meerdere regels
[[<attribute>]...]
[<property-type>]
$<property-name> [= <default-value>]
Voorbeelden
Voorbeeld 1- Minimale klasse-eigenschappen
De eigenschappen van de klasse ExampleProject1 maken gebruik van ingebouwde typen zonder kenmerken of standaardwaarden.
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
De standaardwaarde voor de eigenschappen Name en Assignee is $null omdat ze zijn getypt als tekenreeksen. Dit is een verwijzingstype. De andere eigenschappen hebben de standaardwaarde voor het gedefinieerde type, omdat het eigenschappen van het waardetype zijn. Zie Standaardeigenschapswaarden voor meer informatie over de standaardwaarden voor eigenschappen.
Voorbeeld 2: Klasse-eigenschappen met aangepaste typen
De eigenschappen voor ExampleProject2 bevatten een aangepaste opsomming en klasse die zijn gedefinieerd in PowerShell vóór de klasse 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
Voorbeeld 3- Klasse-eigenschap met een validatiekenmerk
De klasse ExampleProject3 definieert de eigenschap Size als een geheel getal dat groter dan of gelijk moet zijn aan 0 en kleiner dan of gelijk aan 16. Het kenmerk ValidateRange wordt gebruikt om de waarde te beperken.
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
Wanneer ExampleProject3 wordt geïnstitueerde, wordt de grootte standaard ingesteld op 0. Als u de eigenschap instelt op een waarde binnen het geldige bereik, wordt de waarde bijgewerkt.
$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
Wanneer Grootte is ingesteld op een ongeldige waarde buiten het bereik, genereert PowerShell een uitzondering en wordt de waarde niet gewijzigd.
$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
Voorbeeld 4: klasse-eigenschap met een expliciete standaardwaarde
In de klasse ExampleProject4 wordt de waarde voor de eigenschap StartDate standaard ingesteld op de huidige 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
Voorbeeld 5- Verborgen klasse-eigenschap
De eigenschap GUID van de klasse ExampleProject5 heeft het hidden trefwoord. De eigenschap GUID wordt niet weergegeven in de standaarduitvoer voor de klasse of in de lijst met eigenschappen die worden geretourneerd door 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;}
Voorbeeld 6: statische klasse-eigenschap
De klasse ExampleProject6 definieert de statische eigenschap Projects als een lijst met alle gemaakte projecten. De standaardconstructor voor de klasse voegt het nieuwe exemplaar toe aan de lijst met projecten.
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
Voorbeeld 7: een eigenschap definiëren in de constructor
De klasse ExampleProject7 definieert de scripteigenschap Duration in de statische klasseconstructor met de Update-TypeData cmdlet. Het gebruik van de Update-TypeData cmdlet of Add-Member is de enige manier om geavanceerde eigenschappen voor PowerShell-klassen te definiëren.
De eigenschap Duration retourneert een waarde van $null , tenzij zowel de eigenschappen StartDate als EndDate zijn ingesteld en StartDate is gedefinieerd als eerder dan de 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
De standaardweergave voor een exemplaar van de klasse ExampleProject7 bevat de duur. Omdat de eigenschappen StartDate en EndDate niet zijn ingesteld, is $nullde eigenschap 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
Als de eigenschappen juist zijn ingesteld, retourneert de eigenschap Duration een periode die aangeeft hoe lang het project is uitgevoerd.
Standaardeigenschapswaarden
Elke klasse-eigenschap heeft een impliciete standaardwaarde, afhankelijk van het type van de eigenschap.
Als een eigenschap een verwijzingstype is, zoals een tekenreeks of een object, is $nullde impliciete standaardwaarde . Als een eigenschap een waardetype is, zoals een getal, booleaanse waarde of opsomming, heeft de eigenschap een standaardwaarde, afhankelijk van het type:
- Numerieke typen, zoals gehele getallen en getallen met drijvende komma, zijn standaard ingesteld op
0 - Booleaanse waarden zijn standaard ingesteld op
$false - Opsommingen zijn standaard ingesteld op
0, zelfs de opsomming definieert geen label voor0.
Zie Standaardwaarden van C#-typen (C#-verwijzing) voor meer informatie over standaardwaarden in .NET.
Als u een expliciete standaardwaarde voor een eigenschap wilt definiëren, declareert u de eigenschap met een toewijzing aan de standaardwaarde.
Deze definitie voor de klasse ProjectTask definieert bijvoorbeeld een expliciete standaardwaarde voor de eigenschap GUID , waarbij een willekeurige GUID wordt toegewezen aan elk nieuw exemplaar.
class ProjectTask {
[string] $Name
[string] $Description
[string] $Guid = (New-Guid).Guid
}
[ProjectTask]::new()
Name Description Guid
---- ----------- ----
aa96350c-358d-465c-96d1-a49949219eec
Verborgen en statische eigenschappen kunnen ook standaardwaarden hebben.
Verborgen eigenschappen
U kunt eigenschappen van een klasse verbergen door deze te declareren met het hidden trefwoord.
Verborgen klasse-eigenschappen zijn:
- Niet opgenomen in de standaarduitvoer voor de klasse.
- Niet opgenomen in de lijst met klasseleden die worden geretourneerd door de
Get-Membercmdlet. Als u verborgen eigenschappen wilt weergeven metGet-Member, gebruikt u de parameter Force . - Niet weergegeven in tabvoltooiing of IntelliSense, tenzij de voltooiing plaatsvindt in de klasse die de verborgen eigenschap definieert.
- Openbare leden van de klasse. Ze kunnen worden geopend en gewijzigd. Als u een eigenschap verbergt, wordt deze niet privé. Alleen de eigenschap wordt verborgen zoals beschreven in de vorige punten.
Zie about_Hidden voor meer informatie over het hidden trefwoord.
Statische eigenschappen
U kunt een eigenschap definiëren als behorend bij de klasse zelf in plaats van exemplaren van de klasse door de eigenschap te declareren met het static trefwoord. Eigenschappen van statische klasse:
- Zijn altijd beschikbaar, onafhankelijk van klasse-instantiëring.
- Worden gedeeld met alle exemplaren van de klasse.
- Zijn altijd beschikbaar.
- Kunnen worden gewijzigd. Statische eigenschappen kunnen worden bijgewerkt. Ze zijn niet standaard onveranderbaar.
- Live gedurende de hele sessieperiode.
Belangrijk
Statische eigenschappen voor klassen die zijn gedefinieerd in PowerShell zijn niet onveranderbaar. Ze kunnen
Afgeleide klasse-eigenschappen
Wanneer een klasse is afgeleid van een basisklasse, neemt deze de eigenschappen van de basisklasse over. Alle eigenschappen die zijn gedefinieerd voor de basisklasse, met inbegrip van verborgen eigenschappen, zijn beschikbaar voor de afgeleide klasse.
Een afgeleide klasse kan een overgenomen eigenschap overschrijven door deze opnieuw te definiëren in de klassedefinitie. De eigenschap voor de afgeleide klasse gebruikt het opnieuw gedefinieerde type en de standaardwaarde, indien van toepassing. Als de overgenomen eigenschap een standaardwaarde heeft gedefinieerd en de opnieuw gedefinieerde eigenschap niet, heeft de overgenomen eigenschap geen standaardwaarde.
Als een afgeleide klasse een statische eigenschap niet overschrijft, heeft toegang tot de statische eigenschap via de afgeleide klasse toegang tot de statische eigenschap van de basisklasse. Als u de eigenschapswaarde wijzigt via de afgeleide klasse, wordt de waarde op de basisklasse gewijzigd. Elke andere afgeleide klasse die de statische eigenschap niet overschrijft, gebruikt ook de waarde van de eigenschap op de basisklasse. Het bijwerken van de waarde van een overgenomen statische eigenschap in een klasse die de eigenschap niet overschrijft, kan onbedoelde effecten hebben voor klassen die zijn afgeleid van dezelfde basisklasse.
In het volgende voorbeeld ziet u het gedrag voor statische en exemplaareigenschappen voor afgeleide klassen.
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
De InstanceProperty voor DerivedClassC is een lege tekenreeks omdat de klasse de eigenschap opnieuw heeft gedefinieerd zonder een standaardwaarde in te stellen. Voor DerivedClassD is Override de waarde omdat de klasse de eigenschap opnieuw heeft gedefinieerd met die tekenreeks als de standaardwaarde.
"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
Met uitzondering van DerivedClassD is de waarde van de statische eigenschap voor de afgeleide klassen hetzelfde als de basisklasse, omdat deze de eigenschap niet opnieuw definiëren. Dit geldt zelfs voor DerivedClassC, dat van DerivedClassB overerft in plaats van rechtstreeks van 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
Wanneer StaticProperty wordt geopend en gewijzigd via DerivedClassA, is de gewijzigde waarde van invloed op elke klasse, met uitzondering van DerivedClassD.
Zie about_Classes_Inheritance voor meer informatie over klasseovername, waaronder een uitgebreid voorbeeld.
Eigenschapskenmerken gebruiken
PowerShell bevat verschillende kenmerkklassen die u kunt gebruiken om gegevenstypegegevens te verbeteren en de gegevens te valideren die zijn toegewezen aan een eigenschap. Met validatiekenmerken kunt u testen of waarden die aan eigenschappen worden gegeven, voldoen aan gedefinieerde vereisten. Validatie wordt geactiveerd op het moment dat de waarde wordt toegewezen.
Zie about_Functions_Advanced_Parameters voor meer informatie over beschikbare kenmerken.
Instantie-eigenschappen definiëren met Update-TypeData
Naast het rechtstreeks declareren van eigenschappen in de klassedefinitie, kunt u eigenschappen definiëren voor exemplaren van een klasse in de statische constructor met behulp van de Update-TypeData cmdlet.
Gebruik dit codefragment als uitgangspunt voor het patroon. Vervang indien nodig de tekst van de tijdelijke aanduiding tussen punthaken.
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
De Add-Member cmdlet kan eigenschappen en methoden toevoegen aan een klasse in niet-statische constructors, maar de cmdlet wordt uitgevoerd telkens wanneer de constructor wordt aangeroepen. Als Update-TypeData u in de statische constructor gebruikt, zorgt u ervoor dat de code voor het toevoegen van de leden aan de klasse slechts eenmaal in een sessie hoeft te worden uitgevoerd.
Voeg alleen eigenschappen toe aan de klasse in niet-statische constructors wanneer deze niet kunnen worden gedefinieerd met Update-TypeData, zoals alleen-lezeneigenschappen.
Aliaseigenschappen definiëren
Het aliaskenmerk heeft geen effect wanneer het wordt gebruikt voor een declaratie van een klasse-eigenschap. PowerShell gebruikt dit kenmerk alleen om aliassen te definiëren voor cmdlet-, parameter- en functienamen.
Als u een alias voor een klasse-eigenschap wilt definiëren, gebruikt Update-TypeData u met het AliasPropertyMemberType.
Deze definitie van de klasse OperablePair definieert bijvoorbeeld twee gehele getallen x en y met respectievelijk de aliassen LeftHandSide en 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 }
}
Als de aliassen zijn gedefinieerd, hebben gebruikers toegang tot de eigenschappen met beide namen.
$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
Berekende eigenschappen definiëren
Als u een eigenschap wilt definiëren die verwijst naar de waarden van andere eigenschappen, gebruikt u de Update-TypeData cmdlet met het ScriptPropertyMemberType.
Met deze definitie van de klasse Budget worden bijvoorbeeld de eigenschappen Uitgaven en Inkomsten gedefinieerd als matrices van getallen met drijvende komma. De cmdlet wordt gebruikt Update-TypeData om berekende eigenschappen te definiëren voor totale uitgaven, totale inkomsten en netto-inkomsten.
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}
Eigenschappen definiëren met aangepaste get- en set-logica
PowerShell-klasseeigenschappen kunnen aangepaste getter- en setterlogica niet rechtstreeks definiëren. U kunt deze functionaliteit benaderen door een backing-eigenschap te definiëren met het hidden trefwoord en Update-TypeData een zichtbare eigenschap te definiëren met aangepaste logica voor het ophalen en instellen van de waarde.
Definieer standaard de naam van de verborgen backing-eigenschap met een onderstrepingstekenvoorvoegsel en gebruik camel casing. Geef bijvoorbeeld in plaats van TaskCountde verborgen backing-eigenschap _taskCountde naam .
In dit voorbeeld definieert de klasse ProjectSize een verborgen eigenschap geheel getal met de naam _value. Waarde wordt gedefinieerd als een ScriptProperty met aangepaste logica voor het ophalen en instellen van de eigenschap _value. De setter scriptblock verwerkt het converteren van de tekenreeksweergave van het project naar de juiste grootte.
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
}
}
Als de aangepaste getter en setter zijn gedefinieerd, kunt u de eigenschap Value instellen als een geheel getal of een tekenreeks.
$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
Beperkingen
PowerShell-klasseeigenschappen hebben de volgende beperkingen:
Statische eigenschappen zijn altijd veranderlijk. PowerShell-klassen kunnen onveranderbare statische eigenschappen niet definiëren.
Tijdelijke oplossing: Geen.
Eigenschappen kunnen het kenmerk ValidateScript niet gebruiken, omdat kenmerkargumenten voor klasse-eigenschappen constanten moeten zijn.
Tijdelijke oplossing: Definieer een klasse die wordt overgenomen van het type ValidateArgumentsAttribute en gebruik dat kenmerk in plaats daarvan.
Met rechtstreeks gedeclareerde eigenschappen kunnen aangepaste getter- en setter-implementaties niet worden gedefinieerd.
Tijdelijke oplossing: definieer een verborgen eigenschap en gebruik
Update-TypeDataom de zichtbare getter- en setterlogica te definiëren.Eigenschappen kunnen het aliaskenmerk niet gebruiken. Het kenmerk is alleen van toepassing op parameters, cmdlets en functies.
Tijdelijke oplossing: gebruik de
Update-TypeDatacmdlet om aliassen in de klasseconstructors te definiëren.Wanneer een PowerShell-klasse wordt geconverteerd naar JSON met de
ConvertTo-Jsoncmdlet, bevat de uitvoer-JSON alle verborgen eigenschappen en hun waarden.Tijdelijke oplossing: Geen