about_Classes_Properties
Kurze Beschreibung
Beschreibt, wie Eigenschaften für PowerShell-Klassen definiert werden.
Lange Beschreibung
Eigenschaften sind Elemente der Klasse, die Daten enthalten. Eigenschaften werden als Variablen im Klassenbereich deklariert. Eine Eigenschaft kann von jedem integrierten Typ oder einer Instanz einer anderen Klasse sein. Klassen können null oder mehr Eigenschaften aufweisen. Klassen haben keine maximale Eigenschaftsanzahl.
Klasseneigenschaften können eine beliebige Anzahl von Attributen aufweisen, einschließlich der ausgeblendeten und statischen Attribute. Jede Eigenschaftsdefinition muss einen Typ für die Eigenschaft enthalten. Sie können einen Standardwert für eine Eigenschaft definieren.
Syntax
Klasseneigenschaften verwenden die folgenden Syntaxen:
Einzeilige Syntax
[[<attribute>]...] [<property-type>] $<property-name> [= <default-value>]
Mehrzeilige Syntax
[[<attribute>]...]
[<property-type>]
$<property-name> [= <default-value>]
Beispiele
Beispiel 1 – Minimale Klasseneigenschaften
Die Eigenschaften der ExampleProject1-Klasse verwenden integrierte Typen ohne Attribute oder Standardwerte.
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
Der Standardwert für die Eigenschaften Name und Assignee liegt $null darin, dass sie als Zeichenfolgen eingegeben werden, bei denen es sich um einen Verweistyp handelt. Die anderen Eigenschaften weisen den Standardwert für ihren definierten Typ auf, da sie Werttypeigenschaften sind. Weitere Informationen zu den Standardwerten für Eigenschaften finden Sie unter "Standardwerte".
Beispiel 2 : Klasseneigenschaften mit benutzerdefinierten Typen
Die Eigenschaften für ExampleProject2 enthalten eine benutzerdefinierte Aufzählung und Klasse, die in PowerShell vor der ExampleProject2-Klasse definiert ist.
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
Beispiel 3 : Class-Eigenschaft mit einem Überprüfungsattribut
Die ExampleProject3-Klasse definiert die Size-Eigenschaft als ganze Zahl, die größer oder gleich 0 und kleiner als oder gleich 16 sein muss. Es verwendet das ValidateRange-Attribut , um den Wert einzuschränken.
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
Wenn ExampleProject3 instanziiert, wird standardmäßig " Größe " auf "0" festgelegt. Durch Festlegen der Eigenschaft auf einen Wert innerhalb des gültigen Bereichs wird der Wert aktualisiert.
$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
Wenn "Size" auf einen ungültigen Wert außerhalb des Bereichs festgelegt ist, löst PowerShell eine Ausnahme aus, und der Wert wird nicht geändert.
$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
Beispiel 4 : Class-Eigenschaft mit einem expliziten Standardwert
Die ExampleProject4-Klasse verwendet standardmäßig den Wert für die StartDate-Eigenschaft auf das aktuelle 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
Beispiel 5 – Ausgeblendete Klasseneigenschaft
Die Guid-Eigenschaft der ExampleProject5-Klasse weist die hidden Schlüsselwort (keyword) auf. Die Guid-Eigenschaft wird nicht in der Standardausgabe für die Klasse oder in der Liste der eigenschaften angezeigt, die von 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;}
Beispiel 6 – Statische Klasseneigenschaft
Die ExampleProject6-Klasse definiert die statische Projects-Eigenschaft als Liste aller erstellten Projekte. Der Standardkonstruktor für die Klasse fügt die neue Instanz zur Liste der Projekte hinzu.
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
Beispiel 7 – Definieren einer Eigenschaft im Konstruktor
Die ExampleProject7-Klasse definiert die Duration-Skripteigenschaft im statischen Klassenkonstruktor mit dem Update-TypeData Cmdlet. Die Verwendung oder Add-Member das Update-TypeData Cmdlet ist die einzige Möglichkeit, erweiterte Eigenschaften für PowerShell-Klassen zu definieren.
Die Duration-Eigenschaft gibt einen Wert zurück, es $null sei denn, die Eigenschaften "StartDate" und "EndDate" werden festgelegt, und "StartDate" ist vor dem EndDate definiert.
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
Die Standardansicht für eine Instanz der ExampleProject7-Klasse enthält die Dauer. Da die Eigenschaften "StartDate" und "EndDate" nicht festgelegt sind, lautet $nulldie Duration-Eigenschaft .
$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
Nachdem die Eigenschaften richtig festgelegt wurden, gibt die Duration-Eigenschaft einen Zeitbereich zurück, der angibt, wie lange das Projekt ausgeführt wurde.
Standardwerte für Eigenschaften
Jede Klasseneigenschaft weist abhängig vom Typ der Eigenschaft einen impliziten Standardwert auf.
Wenn es sich bei einer Eigenschaft um einen Verweistyp handelt, z. B. eine Zeichenfolge oder ein Objekt, lautet $nullder implizite Standardwert . Wenn eine Eigenschaft ein Werttyp ist, z. B. eine Zahl, ein boolescher Wert oder eine Enumeration, weist die Eigenschaft je nach Typ einen Standardwert auf:
- Numerische Typen, z. B. Ganze Zahlen und Gleitkommazahlen, standardmäßig auf
0 - Boolesche Werte standardmäßig auf
$false - Enumerationen definieren standardmäßig
0, auch wenn die Aufzählung keine Bezeichnung für0.
Weitere Informationen zu Standardwerten in .NET finden Sie unter Standardwerte von C#-Typen (C#-Referenz).
Um einen expliziten Standardwert für eine Eigenschaft zu definieren, deklarieren Sie die Eigenschaft mit einer Zuweisung zum Standardwert.
Diese Definition für die ProjectTask-Klasse definiert beispielsweise einen expliziten Standardwert für die Guid-Eigenschaft und weist jeder neuen Instanz eine zufällige GUID zu.
class ProjectTask {
[string] $Name
[string] $Description
[string] $Guid = (New-Guid).Guid
}
[ProjectTask]::new()
Name Description Guid
---- ----------- ----
aa96350c-358d-465c-96d1-a49949219eec
Ausgeblendete und statische Eigenschaften können auch Standardwerte aufweisen.
Ausgeblendete Eigenschaften
Sie können Eigenschaften einer Klasse ausblenden, indem Sie sie mit dem hidden Schlüsselwort (keyword) deklarieren.
Ausgeblendete Klasseneigenschaften sind:
- Nicht in der Standardausgabe für die Klasse enthalten.
- Nicht in der Liste der vom Cmdlet zurückgegebenen
Get-MemberKlassenmber enthalten. Um ausgeblendete Eigenschaften mitGet-Memberanzuzeigen, verwenden Sie den Force-Parameter . - Wird nicht im Abschluss der Registerkarte oder IntelliSense angezeigt, es sei denn, der Abschluss erfolgt in der Klasse, die die ausgeblendete Eigenschaft definiert.
- Öffentliche Member der Klasse. Auf sie kann zugegriffen und geändert werden. Durch das Ausblenden einer Eigenschaft wird sie nicht privat. Sie blendet die Eigenschaft nur aus, wie in den vorherigen Punkten beschrieben.
Weitere Informationen zum hidden Schlüsselwort (keyword) finden Sie unter about_Hidden.
Statische Eigenschaften
Sie können eine Eigenschaft als Zugehörigkeit zur Klasse selbst und nicht als Instanzen der Klasse definieren, indem Sie die Eigenschaft mit dem static Schlüsselwort (keyword) deklarieren. Statische Klasseneigenschaften:
- Sind immer verfügbar, unabhängig von der Klasseninstanziierung.
- Werden für alle Instanzen der Klasse freigegeben.
- Sind immer verfügbar.
- Kann geändert werden. Statische Eigenschaften können aktualisiert werden. Sie sind standardmäßig nicht unveränderlich.
- Live für die gesamte Sitzungsspanne.
Wichtig
Statische Eigenschaften für klassen, die in PowerShell definiert sind, sind nicht unveränderlich. Sie können
Abgeleitete Klasseneigenschaften
Wenn eine Klasse von einer Basisklasse abgeleitet wird, erbt sie die Eigenschaften der Basisklasse. Alle für die Basisklasse definierten Eigenschaften, einschließlich ausgeblendeter Eigenschaften, sind für die abgeleitete Klasse verfügbar.
Eine abgeleitete Klasse kann eine geerbte Eigenschaft überschreiben, indem sie in der Klassendefinition neu definiert wird. Die Eigenschaft für die abgeleitete Klasse verwendet ggf. den neu definierten Typ und standardwert. Wenn die geerbte Eigenschaft einen Standardwert definiert hat und die neu definierte Eigenschaft nicht, hat die geerbte Eigenschaft keinen Standardwert.
Wenn eine abgeleitete Klasse eine statische Eigenschaft nicht überschreibt, greift der Zugriff auf die statische Eigenschaft über die abgeleitete Klasse auf die statische Eigenschaft der Basisklasse zu. Durch Ändern des Eigenschaftswerts durch die abgeleitete Klasse wird der Wert für die Basisklasse geändert. Jede andere abgeleitete Klasse, die die statische Eigenschaft nicht überschreibt, verwendet auch den Wert der Eigenschaft für die Basisklasse. Das Aktualisieren des Werts einer geerbten statischen Eigenschaft in einer Klasse, die die Eigenschaft nicht überschreibt, hat möglicherweise unbeabsichtigte Effekte für Klassen, die von derselben Basisklasse abgeleitet wurden.
Das folgende Beispiel zeigt das Verhalten für statische Und Instanzeigenschaften für abgeleitete 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
Die InstanceProperty für DerivedClassC ist eine leere Zeichenfolge, da die Klasse die Eigenschaft neu definiert hat, ohne einen Standardwert festzulegen. Für DerivedClassD liegt Override der Wert darin, dass die Klasse die Eigenschaft mit dieser Zeichenfolge als Standardwert neu definiert hat.
"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
Mit Ausnahme von DerivedClassD ist der Wert der statischen Eigenschaft für die abgeleiteten Klassen identisch mit der Basisklasse, da sie die Eigenschaft nicht neu definieren. Dies gilt auch für DerivedClassC, das anstelle von BaseClassB direkt von "DerivedClassB" erbt.
[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
Wenn staticProperty über DerivedClassA aufgerufen und geändert wird, wirkt sich der geänderte Wert auf jede Klasse mit Ausnahme von DerivedClassD aus.
Weitere Informationen zur Klassenvererbung, einschließlich eines umfassenden Beispiels, finden Sie unter about_Classes_Inheritance.
Verwenden von Eigenschaftsattributen
PowerShell enthält mehrere Attributklassen, die Sie verwenden können, um Datentypinformationen zu verbessern und die daten zu überprüfen, die einer Eigenschaft zugewiesen sind. Mithilfe von Überprüfungsattributen können Sie testen, ob die werte, die eigenschaften angegeben wurden, den definierten Anforderungen entsprechen. Die Überprüfung wird ausgelöst, sobald der Wert zugewiesen ist.
Weitere Informationen zu verfügbaren Attributen finden Sie unter about_Functions_Advanced_Parameters.
Definieren von Instanzeigenschaften mit Update-TypeData
Über das direkte Deklarieren von Eigenschaften in der Klassendefinition hinaus können Sie Eigenschaften für Instanzen einer Klasse im statischen Konstruktor mithilfe des Update-TypeData Cmdlets definieren.
Verwenden Sie diesen Codeausschnitt als Ausgangspunkt für das Muster. Ersetzen Sie den Platzhaltertext nach Bedarf in winkeln Klammern.
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
}
}
}
Tipp
Das Add-Member Cmdlet kann einer Klasse in nicht statischen Konstruktoren Eigenschaften und Methoden hinzufügen, das Cmdlet wird jedoch jedes Mal ausgeführt, wenn der Konstruktor aufgerufen wird. Die Verwendung Update-TypeData im statischen Konstruktor stellt sicher, dass der Code zum Hinzufügen der Member zur Klasse nur einmal in einer Sitzung ausgeführt werden muss.
Fügen Sie der Klasse nur Eigenschaften in nicht statischen Konstruktoren hinzu, wenn sie nicht mit Update-TypeDataschreibgeschützten Eigenschaften definiert werden können.
Definieren von Aliaseigenschaften
Das Alias-Attribut hat keine Auswirkung, wenn es für eine Klasseneigenschaftsdeklaration verwendet wird. PowerShell verwendet dieses Attribut nur zum Definieren von Aliasen für Cmdlet-, Parameter- und Funktionsnamen.
Verwenden Sie zum Definieren eines Alias für eine Klasseneigenschaft den MemberType.To define an alias for a class property, use Update-TypeData with the AliasPropertyMemberType.
Diese Definition der OperablePair-Klasse definiert beispielsweise zwei ganzzahlige Eigenschaften x und y mit den Aliasen LeftHandSide bzw. 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 }
}
Nachdem die Aliase definiert wurden, können Benutzer auf die Eigenschaften mit beiden Namen zugreifen.
$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
Definieren berechneter Eigenschaften
Um eine Eigenschaft zu definieren, die auf die Werte anderer Eigenschaften verweist, verwenden Sie das Update-TypeData Cmdlet mit dem ScriptPropertyMemberType.
Diese Definition der Budget-Klasse definiert beispielsweise die Eigenschaften "Ausgaben" und "Einnahmen" als Arrays von Gleitkommazahlen. Es verwendet das Update-TypeData Cmdlet, um berechnete Eigenschaften für Gesamtausgaben, Gesamteinnahmen und Nettoeinnahmen zu definieren.
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}
Definieren von Eigenschaften mit benutzerdefinierter Get- und Set-Logik
PowerShell-Klasseneigenschaften können keine benutzerdefinierte Getter- und Setterlogik direkt definieren. Sie können diese Funktionalität annähern, indem Sie eine Sicherungseigenschaft mit dem hidden Schlüsselwort (keyword) definieren und Update-TypeData eine sichtbare Eigenschaft mit benutzerdefinierter Logik zum Abrufen und Festlegen des Werts definieren.
Definieren Sie in der Konvention den Namen der ausgeblendeten Sicherungseigenschaft mit einem Unterstrichpräfix, und verwenden Sie die Kamel-Groß-/Kleinschreibung. Nennen Sie z. B. anstelle von TaskCount, die ausgeblendete Sicherungseigenschaft _taskCount.
In diesem Beispiel definiert die ProjectSize-Klasse eine ausgeblendete ganzzahlige Eigenschaft namens _value. Es definiert "Value " als benutzerdefinierte ScriptProperty Logik zum Abrufen und Festlegen der _value-Eigenschaft . Der Setter scriptblock verarbeitet die Konvertierung der Zeichenfolgendarstellung des Projekts in die richtige Größe.
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
}
}
Mit dem definierten benutzerdefinierten Getter und Setter können Sie die Value-Eigenschaft entweder als ganze Zahl oder als Zeichenfolge festlegen.
$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
Begrenzungen
PowerShell-Klasseneigenschaften weisen die folgenden Einschränkungen auf:
Statische Eigenschaften sind immer änderbar. PowerShell-Klassen können unveränderliche statische Eigenschaften nicht definieren.
Abhilfen: Keine.
Eigenschaften können das ValidateScript-Attribut nicht verwenden, da Klasseneigenschaften-Attributargumente Konstanten sein müssen.
Problemumgehung: Definieren Sie eine Klasse, die vom ValidateArgumentsAttribute-Typ erbt, und verwenden Sie stattdessen dieses Attribut.
Direkt deklarierte Eigenschaften können keine benutzerdefinierten Getter- und Setterimplementierungen definieren.
Problemumgehung: Definieren Sie eine ausgeblendete Eigenschaft, und definieren
Update-TypeDataSie die sichtbare Getter- und Setterlogik.Eigenschaften können das Alias-Attribut nicht verwenden. Das Attribut gilt nur für Parameter, Cmdlets und Funktionen.
Problemumgehung: Verwenden Sie das
Update-TypeDataCmdlet, um Aliase in den Klassenkonstruktoren zu definieren.Wenn eine PowerShell-Klasse mit dem
ConvertTo-JsonCmdlet in JSON konvertiert wird, enthält die Ausgabe-JSON alle ausgeblendeten Eigenschaften und deren Werte.Abhilfen: Keine
Weitere Informationen
Feedback
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unter https://aka.ms/ContentUserFeedback.
Feedback senden und anzeigen für