about_Classes_Properties
Korte beschrijving
Hierin wordt beschreven hoe u eigenschappen definieert voor PowerShell-klassen.
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 of een exemplaar van een andere klasse zijn. Klassen kunnen nul of meer eigenschappen hebben. Klassen hebben geen maximumaantal eigenschappen.
Klasse-eigenschappen kunnen een willekeurig aantal kenmerken hebben, waaronder de verborgen en statische kenmerken. Elke eigenschapsdefinitie moet een type voor de eigenschap bevatten. U kunt een standaardwaarde voor een eigenschap definiëren.
Syntaxis
Klasse-eigenschappen gebruiken de volgende syntaxis:
Syntaxis van één regel
[[<attribute>]...] [<property-type>] $<property-name> [= <default-value>]
Syntaxis met 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 Naam en Toegewezen gebruiker is $null omdat deze als tekenreeksen worden getypt. 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 is 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 Grootte 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ïnstitueert, 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 guid-eigenschap van de klasse ExampleProject5 heeft het hidden trefwoord. De guid-eigenschap 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 eigenschap static 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 eigenschap Duration-script in de statische klasseconstructor met de Update-TypeData cmdlet. Het gebruik van de Update-TypeData of Add-Member cmdlet is de enige manier om geavanceerde eigenschappen voor PowerShell-klassen te definiëren.
De eigenschap Duur retourneert een waarde van $null tenzij zowel de eigenschappen Begindatum als Einddatum zijn ingesteld en Begindatum is gedefinieerd dat deze eerder is dan de Einddatum.
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 Begindatum en Einddatum niet zijn ingesteld, is $nullde eigenschap Duur.
$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 Duur een periode die aangeeft hoe lang het project is uitgevoerd.
Standaardeigenschapswaarden
Elke klasse-eigenschap heeft een impliciete standaardwaarde, afhankelijk van het type 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 worden standaard ingesteld op
$false - Opsommingen zijn standaard ingesteld
0op , 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 guid-eigenschap en wijst een willekeurige GUID toe 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 ze 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 door de
Get-Membercmdlet worden geretourneerd. 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 klas. Ze kunnen worden geopend en gewijzigd. Het verbergen van een eigenschap maakt het niet privé. De eigenschap wordt alleen 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 tot de klasse zelf in plaats van exemplaren van de klasse door de eigenschap met het static trefwoord te declareren. Eigenschappen van statische klassen:
- Zijn altijd beschikbaar, onafhankelijk van klasse-instantiëring.
- Worden gedeeld in alle exemplaren van de klasse.
- Zijn altijd beschikbaar.
- Kunnen worden gewijzigd. Statische eigenschappen kunnen worden bijgewerkt. Ze zijn niet standaard onveranderbaar.
- Live voor het hele sessiebereik.
Belangrijk
Statische eigenschappen voor klassen die zijn gedefinieerd in PowerShell zijn niet onveranderbaar. Ze kunnen
Eigenschappen van afgeleide klassen
Wanneer een klasse is afgeleid van een basisklasse, neemt deze de eigenschappen van de basisklasse over. Alle eigenschappen die zijn gedefinieerd op de basisklasse, inclusief verborgen eigenschappen, zijn beschikbaar in de afgeleide klasse.
Een afgeleide klasse kan een overgenomen eigenschap overschrijven door deze opnieuw te definiëren in de klassedefinitie. De eigenschap van de afgeleide klasse maakt gebruik van 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 geen statische eigenschap 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, heeft mogelijk onbedoelde effecten voor klassen die zijn afgeleid van dezelfde basisklasse.
In het volgende voorbeeld ziet u het gedrag voor statische eigenschappen en instantie-eigenschappen 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
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 met die tekenreeks opnieuw heeft gedefinieerd 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 ze de eigenschap niet opnieuw definiëren. Dit geldt zelfs voor DerivedClassC, die wordt overgenomen van DerivedClassB 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 overname van klassen, waaronder een uitgebreid voorbeeld.
Eigenschapskenmerken gebruiken
PowerShell bevat verschillende kenmerkklassen die u kunt gebruiken om gegevenstypegegevens te verbeteren en de gegevens te valideren die aan een eigenschap zijn toegewezen. Met validatiekenmerken kunt u testen of de waarden die aan eigenschappen zijn gegeven, voldoen aan gedefinieerde vereisten. Validatie wordt geactiveerd op het moment dat de waarde is toegewezen.
Zie about_Functions_Advanced_Parameters voor meer informatie over beschikbare kenmerken.
Exemplaareigenschappen 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 fragment 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 elke keer uitgevoerd wanneer de constructor wordt aangeroepen. Het gebruik Update-TypeData in de statische constructor zorgt 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 ze niet kunnen worden gedefinieerd met Update-TypeData, zoals alleen-lezeneigenschappen.
Aliaseigenschappen definiëren
Het kenmerk Alias heeft geen effect wanneer het wordt gebruikt voor de declaratie van een klasse-eigenschap. PowerShell gebruikt dat 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 dit met het AliasProperty MemberType.
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 een van 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 ScriptProperty MemberType.
Deze definitie van de klasse Budget definieert bijvoorbeeld de eigenschappen Uitgaven en Inkomsten als matrices van drijvendekommagetallen. De cmdlet gebruikt de Update-TypeData cmdlet om berekende eigenschappen te definiëren voor de totale onkosten, de totale inkomsten en het netto-inkomen.
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 setlogica
Eigenschappen van PowerShell-klassen kunnen geen aangepaste getter- en setterlogica rechtstreeks definiëren. U kunt deze functionaliteit benaderen door een back-upeigenschap te definiëren met het hidden trefwoord en een Update-TypeData zichtbare eigenschap te definiëren met aangepaste logica voor het ophalen en instellen van de waarde.
Definieer volgens de conventie de naam van de verborgen back-upeigenschap met een onderstrepingstekenvoorvoegsel en gebruik kameelbehuizing. Geef in plaats van TaskCountbijvoorbeeld de verborgen back-upeigenschap _taskCounteen naam.
In dit voorbeeld definieert de klasse ProjectSize een verborgen geheel getal met de naam _value. Deze definieert Waarde als een ScriptProperty met aangepaste logica voor het ophalen en instellen van de eigenschap _value. De setterscriptblock 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 Waarde instellen als een geheel getal of 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
Eigenschappen van PowerShell-klassen hebben de volgende beperkingen:
Statische eigenschappen zijn altijd veranderlijk. PowerShell-klassen kunnen geen onveranderbare statische eigenschappen definiëren.
Oplossing: Geen.
Eigenschappen kunnen het kenmerk ValidateScript niet gebruiken, omdat argumenten van het kenmerk klasse-eigenschap constanten moeten zijn.
Tijdelijke oplossing: Definieer een klasse die wordt overgenomen van het type ValidateArgumentsAttribute en gebruik dat kenmerk in plaats daarvan.
Rechtstreeks gedeclareerde eigenschappen kunnen geen aangepaste getter- en setter-implementaties definiëren.
Tijdelijke oplossing: definieer een verborgen eigenschap en gebruik
Update-TypeDatadeze om 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 de bijbehorende waarden.Oplossing: Geen
