Freigeben über

about_Classes_Properties

Kurzbeschreibung

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 Attributen. 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>]

Mehrzeilensyntax

[[<attribute>]...]
[<property-type>]
$<property-name> [= <default-value>]

Examples

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 ist $null, da 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 definiert ist, bevor die ExampleProject2-klasse.

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 eigenschaft Size 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 "0" "Size". 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 Größe 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 das schlüsselwort hidden auf. Die Guid--Eigenschaft wird in der Standardausgabe für die Klasse oder in der Liste der von Get-Memberzurückgegebenen Eigenschaften nicht angezeigt.

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 eigenschaft Duration Script im statischen Klassenkonstruktor mit dem Cmdlet Update-TypeData. Die Verwendung des Cmdlets Update-TypeData oder Add-Member ist die einzige Möglichkeit zum Definieren erweiterter Eigenschaften für PowerShell-Klassen.

Die Duration-Eigenschaft gibt einen Wert von $null zurück, es sei denn, die Eigenschaften StartDate und EndDate werden festgelegt, und StartDate- vor dem EndDate-definiert ist.

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, ist die Duration-Eigenschaft $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

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 Verweistyphandelt, z. B. eine Zeichenfolge oder ein Objekt, wird der implizite Standardwert $null. Wenn eine Eigenschaft ein Werttypist, 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, werden standardmäßig als 0
  • Boolesche Werte werden standardmäßig auf $false
  • Enumerationen werden standardmäßig auf 0festgelegt, auch wenn die Aufzählung keine Bezeichnung für 0definiert.

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, wobei jeder neuen Instanz eine zufällige GUID zugewiesen wird.

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 schlüsselwort hidden deklarieren. Ausgeblendete Klasseneigenschaften sind:

  • Nicht in der Standardausgabe für die Klasse enthalten.
  • Nicht in der Liste der Vom cmdlet Get-Member zurückgegebenen Klassenmitglieder enthalten. Um ausgeblendete Eigenschaften mit Get-Memberanzuzeigen, verwenden Sie den Parameter Force.
  • 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 schlüsselwort hidden 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 schlüsselwort static 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 auf einen beliebigen gültigen Wert überschrieben werden, wie durch den Typ und die Attribute der statischen Eigenschaft definiert.

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 der Wert Override, da 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, die von DerivedClassB- anstelle direkt von BaseClasserbt.

[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-geändert wird, wirkt sich der geänderte Wert auf jede Klasse aus, mit Ausnahme von DerivedClassD-.

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 cmdlets Update-TypeData 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
        }
    }
}

Trinkgeld

Das Cmdlet Add-Member 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. Durch die Verwendung von Update-TypeData im statischen Konstruktor wird sichergestellt, 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-TypeDatadefiniert werden können, z. B. schreibgeschützte Eigenschaften.

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.

Um einen Alias für eine Klasseneigenschaft zu definieren, verwenden Sie Update-TypeData mit dem AliasPropertyMemberType-.

Beispielsweise definiert diese Definition der OperablePair Klasse 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 cmdlet Update-TypeData mit dem ScriptPropertyMemberType-.

Beispielsweise definiert diese Definition der klasse Budget die Expenses und Revenues Eigenschaften als Arrays von Gleitkommazahlen. Es verwendet das Cmdlet Update-TypeData, 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 schlüsselwort hidden definieren und Update-TypeData verwenden, um eine sichtbare Eigenschaft mit benutzerdefinierter Logik zum Abrufen und Festlegen des Werts zu 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 TaskCountdie ausgeblendete Sicherungseigenschaft _taskCount.

In diesem Beispiel definiert die ProjectSize Klasse eine ausgeblendete ganzzahlige Eigenschaft namens _value. Sie definiert Value als ScriptProperty mit benutzerdefinierter 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 eigenschaft Value 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

Einschränkungen

PowerShell-Klasseneigenschaften weisen die folgenden Einschränkungen auf:

  • Statische Eigenschaften sind immer änderbar. PowerShell-Klassen können unveränderliche statische Eigenschaften nicht definieren.

    Problemumgehung: Keine.

  • Eigenschaften können das attribut "ValidateScript" nicht verwenden, da Klasseneigenschaftsattributargumente 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 verwenden Sie Update-TypeData, um die sichtbare Getter- und Setterlogik zu definieren.

  • Eigenschaften können das attribut Alias nicht verwenden. Das Attribut gilt nur für Parameter, Cmdlets und Funktionen.

    Problemumgehung: Verwenden Sie das Cmdlet Update-TypeData, um Aliase in den Klassenkonstruktoren zu definieren.

  • Wenn eine PowerShell-Klasse mit dem Cmdlet ConvertTo-Json in JSON konvertiert wird, enthält die Ausgabe-JSON alle ausgeblendeten Eigenschaften und deren Werte.

    Problemumgehung: Keine

Siehe auch

  • Last updated on