about_Classes_Properties

  • Článek

Krátký popis

Popisuje, jak definovat vlastnosti pro třídy PowerShellu.

Dlouhý popis

Vlastnosti jsou členy třídy, která obsahuje data. Vlastnosti jsou deklarovány jako proměnné v oboru třídy. Vlastnost může být libovolného předdefinovaný typ nebo instance jiné třídy. Třídy mohou nula nebo více vlastností. Třídy nemají maximální počet vlastností.

Vlastnosti třídy můžou mít libovolný počet atributů, včetně skrytých a statických atributů. Každá definice vlastnosti musí obsahovat typ vlastnosti. Můžete definovat výchozí hodnotu vlastnosti.

Syntaxe

Vlastnosti třídy používají následující syntaxe:

Jednořádková syntaxe

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

Víceřádkové syntaxe

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

Příklady

Příklad 1 – Minimální vlastnosti třídy

Vlastnosti Třídy ExampleProject1 používají předdefinované typy bez jakýchkoli atributů nebo výchozích hodnot.

class ExampleProject1 {
    [string]   $Name
    [int]      $Size
    [bool]     $Completed
    [string]   $Assignee
    [datetime] $StartDate
    [datetime] $EndDate
    [datetime] $DueDate
}

[ExampleProject1]::new()

$null -eq ([ExampleProject1]::new()).Name

Name      :
Size      : 0
Completed : False
StartDate : 1/1/0001 12:00:00 AM
EndDate   : 1/1/0001 12:00:00 AM
DueDate   : 1/1/0001 12:00:00 AM

True

Výchozí hodnota vlastností Name a Assignee je $null , protože jsou zadány jako řetězce, což je typ odkazu. Ostatní vlastnosti mají výchozí hodnotu pro jejich definovaný typ, protože se jedná o vlastnosti typu hodnoty. Další informace o výchozích hodnotách vlastností naleznete v tématu Výchozí hodnoty vlastností.

Příklad 2 – Vlastnosti třídy s vlastními typy

Vlastnosti ExampleProject2 zahrnují vlastní výčet a třídu definovanou v PowerShellu před ExampleProject2 třídy.

enum ProjectState {
    NotTriaged
    ReadyForWork
    Committed
    Blocked
    InProgress
    Done
}

class ProjectAssignee {
    [string] $DisplayName
    [string] $UserName

    [string] ToString() {
        return "$($this.DisplayName) ($($this.UserName))"
    }
}

class ExampleProject2 {
    [string]          $Name
    [int]             $Size
    [ProjectState]    $State
    [ProjectAssignee] $Assignee
    [datetime]        $StartDate
    [datetime]        $EndDate
    [datetime]        $DueDate
}

[ExampleProject2]@{
    Name     = 'Class Property Documentation'
    Size     = 8
    State    = 'InProgress'
    Assignee = @{
        DisplayName = 'Mikey Lombardi'
        UserName    = 'michaeltlombardi'
    }
    StartDate = '2023-10-23'
    DueDate   = '2023-10-27'
}

Name      : Class Property Documentation
Size      : 8
State     : InProgress
Assignee  : Mikey Lombardi (michaeltlombardi)
StartDate : 10/23/2023 12:00:00 AM
EndDate   : 1/1/0001 12:00:00 AM
DueDate   : 10/27/2023 12:00:00 AM

Příklad 3 – vlastnost třídy s ověřovacím atributem

ExampleProject3 třída definuje Size vlastnost jako celé číslo, které musí být větší nebo rovno 0 a menší než nebo rovno 16. K omezení hodnoty používá atribut ValidateRange .

class ExampleProject3 {
                           [string]   $Name
    [ValidateRange(0, 16)] [int]      $Size
                           [bool]     $Completed
                           [string]   $Assignee
                           [datetime] $StartDate
                           [datetime] $EndDate
                           [datetime] $DueDate
}

$project = [ExampleProject3]::new()
$project

Name      :
Size      : 0
Completed : False
Assignee  :
StartDate : 1/1/0001 12:00:00 AM
EndDate   : 1/1/0001 12:00:00 AM
DueDate   : 1/1/0001 12:00:00 AM

Když instance ExampleProject3 vytvoří instanci, výchozí hodnota Velikost je 0. Nastavení vlastnosti na hodnotu v platném rozsahu aktualizuje hodnotu.

$project.Size = 8
$project

Name      :
Size      : 8
Completed : False
Assignee  :
StartDate : 1/1/0001 12:00:00 AM
EndDate   : 1/1/0001 12:00:00 AM
DueDate   : 1/1/0001 12:00:00 AM

Pokud je velikost nastavena na neplatnou hodnotu mimo rozsah, PowerShell vyvolá výjimku a hodnota se nezmění.

$project.Size = 32
$project.Size = -1

$project

SetValueInvocationException:
Line |
   1 |  $project.Size = 32
     |  ~~~~~~~~~~~~~~~~~~
     | Exception setting "Size": "The 32 argument is greater than the
     | maximum allowed range of 16. Supply an argument that is less than
     | or equal to 16 and then try the command again."

SetValueInvocationException:
Line |
   2 |  $project.Size = -1
     |  ~~~~~~~~~~~~~~~~~~
     | Exception setting "Size": "The -1 argument is less than the minimum
     | allowed range of 0. Supply an argument that is greater than or
     | equal to 0 and then try the command again."

Name      :
Size      : 8
Completed : False
Assignee  :
StartDate : 1/1/0001 12:00:00 AM
EndDate   : 1/1/0001 12:00:00 AM
DueDate   : 1/1/0001 12:00:00 AM

Příklad 4 – vlastnost třídy s explicitní výchozí hodnotou

ExampleProject4 třída výchozí hodnotu Pro StartDate vlastnost aktuální datum.

class ExampleProject4 {
    [string]   $Name
    [int]      $Size
    [bool]     $Completed
    [string]   $Assignee
    [datetime] $StartDate = (Get-Date).Date
    [datetime] $EndDate
    [datetime] $DueDate
}

[ExampleProject4]::new()

[ExampleProject4]::new().StartDate -eq (Get-Date).Date

Name      :
Size      : 0
Completed : False
Assignee  :
StartDate : 10/23/2023 12:00:00 AM
EndDate   : 1/1/0001 12:00:00 AM
DueDate   : 1/1/0001 12:00:00 AM

True

Příklad 5 – vlastnost Skryté třídy

Guid vlastnost ExampleProject5 třídy má hidden klíčové slovo. Vlastnost Guid se nezobrazuje ve výchozím výstupu pro třídu nebo v seznamu vlastností vrácených Get-Member.

class ExampleProject5 {
           [string]   $Name
           [int]      $Size
           [bool]     $Completed
           [string]   $Assignee
           [datetime] $StartDate
           [datetime] $EndDate
           [datetime] $DueDate
    hidden [string]   $Guid      = (New-Guid).Guid
}

$project = [ExampleProject5]::new()

"Project GUID: $($project.Guid)"

$project

$project | Get-Member -MemberType Properties | Format-Table

Project GUID: c72cef84-057c-4649-8940-13490dcf72f0

Name      :
Size      : 0
Completed : False
Assignee  :
StartDate : 1/1/0001 12:00:00 AM
EndDate   : 1/1/0001 12:00:00 AM
DueDate   : 1/1/0001 12:00:00 AM


   TypeName: ExampleProject5

Name      MemberType Definition
----      ---------- ----------
Assignee  Property   string Assignee {get;set;}
Completed Property   bool Completed {get;set;}
DueDate   Property   datetime DueDate {get;set;}
EndDate   Property   datetime EndDate {get;set;}
Name      Property   string Name {get;set;}
Size      Property   int Size {get;set;}
StartDate Property   datetime StartDate {get;set;}

Příklad 6 – Statická vlastnost třídy

ExampleProject6 třída definuje static Projects vlastnost jako seznam všech vytvořených projektů. Výchozí konstruktor pro třídu přidá novou instanci do seznamu projektů.

class ExampleProject6 {
           [string]            $Name
           [int]               $Size
           [bool]              $Completed
           [string]            $Assignee
           [datetime]          $StartDate
           [datetime]          $EndDate
           [datetime]          $DueDate
    hidden [string]            $Guid     = (New-Guid).Guid
    static [ExampleProject6[]] $Projects = @()

    ExampleProject6() {
        [ExampleProject6]::Projects += $this
    }
}

"Project Count: $([ExampleProject6]::Projects.Count)"

$project1 = [ExampleProject6]@{ Name = 'Project_1' }
$project2 = [ExampleProject6]@{ Name = 'Project_2' }

[ExampleProject6]::Projects | Select-Object -Property Name, Guid

Project Count: 0

Name      Guid
----      ----
Project_1 75e7c8a0-f8d1-433a-a5be-fd7249494694
Project_2 6c501be4-e68c-4df5-8fce-e49dd8366afe

Příklad 7 – Definování vlastnosti v konstruktoru

ExampleProject7 třída definuje Duration script vlastnost v konstruktoru statické třídy s rutinouUpdate-TypeData. Použití nebo Add-Member rutiny Update-TypeData je jediný způsob, jak definovat pokročilé vlastnosti pro třídy PowerShellu.

Vlastnost Duration vrátí hodnotu $null , pokud nejsou nastaveny vlastnosti StartDate a EndDate a Hodnota StartDate je definována tak, aby byla dřívější než EndDate.

class ExampleProject7 {
    [string]   $Name
    [int]      $Size
    [bool]     $Completed
    [string]   $Assignee
    [datetime] $StartDate
    [datetime] $EndDate
    [datetime] $DueDate

    static [hashtable[]] $MemberDefinitions = @(
        @{
            MemberName = 'Duration'
            MemberType = 'ScriptProperty'
            Value      = {
                [datetime]$UnsetDate = 0

                $StartNotSet   = $this.StartDate -eq $UnsetDate
                $EndNotSet     = $this.EndDate   -eq $UnsetDate
                $StartAfterEnd = $this.StartDate -gt $this.EndDate

                if ($StartNotSet -or $EndNotSet -or $StartAfterEnd) {
                    return $null
                }

                return $this.EndDate - $this.StartDate
            }
        }
    )

    static ExampleProject7() {
        $TypeName = [ExampleProject7].Name
        foreach ($Definition in [ExampleProject7]::MemberDefinitions) {
            Update-TypeData -TypeName $TypeName @Definition
        }
    }

    ExampleProject7() {}

    ExampleProject7([string]$Name) {
        $this.Name = $Name
    }
}

$Project = [ExampleProject7]::new()
$Project

$null -eq $Project.Duration

Duration  :
Name      :
Size      : 0
Completed : False
Assignee  :
StartDate : 1/1/0001 12:00:00 AM
EndDate   : 1/1/0001 12:00:00 AM
DueDate   : 1/1/0001 12:00:00 AM

True

Výchozí zobrazení instance Třídy ExampleProject7 zahrnuje dobu trvání. Vzhledem k tomu, že vlastnosti StartDate a EndDate nejsou nastaveny, je $nullvlastnost 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

Při správné nastavení vlastností vrátí vlastnost Duration časový rozsah představující dobu, po které se projekt spustil.

Výchozí hodnoty vlastností

Každá vlastnost třídy má implicitní výchozí hodnotu v závislosti na typu vlastnosti.

Pokud je vlastnost typu odkazu, jako je řetězec nebo objekt, implicitní výchozí hodnota je $null. Pokud je vlastnost typ hodnoty, například číslo, logická hodnota nebo výčet, má vlastnost výchozí hodnotu v závislosti na typu:

  • Číselné typy, jako jsou celá čísla a čísla s plovoucí desetinou čárkou, mají výchozí hodnotu 0
  • Výchozí logické hodnoty $false
  • Výčty mají výchozí hodnotu 0, ani výčet nedefinuje popisek pro 0.

Další informace o výchozích hodnotách v .NET najdete v tématu Výchozí hodnoty typů jazyka C# (referenční dokumentace jazyka C#).

Chcete-li definovat explicitní výchozí hodnotu vlastnosti, deklarujte vlastnost s přiřazením výchozí hodnoty.

Například tato definice pro ProjectTask třída definuje explicitní výchozí hodnotu pro Guid vlastnost, přiřazení náhodného GUID ke každé nové instanci.

class ProjectTask {
    [string] $Name
    [string] $Description
    [string] $Guid = (New-Guid).Guid
}

[ProjectTask]::new()

Name Description Guid
---- ----------- ----
                 aa96350c-358d-465c-96d1-a49949219eec

Skryté a statické vlastnosti můžou mít také výchozí hodnoty.

Skryté vlastnosti

Vlastnosti třídy můžete skrýt deklarováním pomocí klíčového hidden slova. Skryté vlastnosti třídy jsou:

  • Nezahrnut do výchozího výstupu pro třídu.
  • Součástí seznamu členů třídy vrácených rutinou Get-Member není. Pokud chcete zobrazit skryté vlastnosti pomocí Get-Memberparametru Force .
  • Nezobrazuje se v dokončování tabulátoru nebo IntelliSense, pokud nedojde k dokončení ve třídě, která definuje skrytou vlastnost.
  • Veřejné členy třídy. K nim je možné přistupovat a upravovat. Skrytí vlastnosti ho neudělá jako soukromou. Skryje vlastnost, jak je popsáno v předchozích bodech.

Další informace o klíčovém slově hidden najdete v tématu about_Hidden.

Statické vlastnosti

Vlastnost můžete definovat jako patřící samotné třídě namísto instancí třídy deklarováním vlastnosti s klíčovým slovem static . Vlastnosti statické třídy:

  • Jsou vždy k dispozici nezávisle na vytváření instancí třídy.
  • Sdílí se napříč všemi instancemi třídy.
  • Jsou vždy k dispozici.
  • Je možné je upravit. Statické vlastnosti je možné aktualizovat. Ve výchozím nastavení nejsou neměnné.
  • Živě pro celou relaci.

Důležité

Statické vlastnosti pro třídy definované v PowerShellu nejsou neměnné. Mohou

Odvozené vlastnosti třídy

Když třída je odvozena od základní třídy, dědí vlastnosti základní třídy. Všechny vlastnosti definované v základní třídě, včetně skrytých vlastností, jsou k dispozici v odvozené třídě.

Odvozená třída může přepsat zděděnou vlastnost tím, že ji předefinuje v definici třídy. Vlastnost odvozené třídy používá redefinovaný typ a výchozí hodnotu, pokud existuje. Pokud zděděná vlastnost definovala výchozí hodnotu a předdefinovaná vlastnost ne, zděděná vlastnost nemá žádnou výchozí hodnotu.

Pokud odvozená třída nepřepíše statickou vlastnost, přístup ke statické vlastnosti prostřednictvím odvozené třídy přistupuje ke statické vlastnosti základní třídy. Úprava hodnoty vlastnosti prostřednictvím odvozené třídy upraví hodnotu základní třídy. Všechny ostatní odvozené třídy, které nepřepíší statickou vlastnost, také používá hodnotu vlastnosti základní třídy. Aktualizace hodnoty zděděné statické vlastnosti ve třídě, která nepřepíše vlastnost, může mít nezamýšlené účinky pro třídy odvozené ze stejné základní třídy.

Následující příklad ukazuje chování statických vlastností a vlastností instance u odvozených tříd.

class BaseClass {
    static [string] $StaticProperty = 'Static'
    [string] $InstanceProperty = 'Instance'
}
class DerivedClassA : BaseClass     {}
class DerivedClassB : BaseClass     {}
class DerivedClassC : DerivedClassB {
    [string] $InstanceProperty
}
class DerivedClassD : BaseClass {
    static [string] $StaticProperty = 'Override'
    [string] $InstanceProperty = 'Override'
}

"Base instance      => $([BaseClass]::new().InstanceProperty)"
"Derived instance A => $([DerivedClassA]::new().InstanceProperty)"
"Derived instance B => $([DerivedClassB]::new().InstanceProperty)"
"Derived instance C => $([DerivedClassC]::new().InstanceProperty)"
"Derived instance D => $([DerivedClassD]::new().InstanceProperty)"

Base instance      => Instance
Derived instance A => Instance
Derived instance B => Instance
Derived instance C =>
Derived instance D => Override

InstanceProperty pro DerivedClassC je prázdný řetězec, protože třída předefinovala vlastnost bez nastavení výchozí hodnoty. Pro DerivedClassD hodnota je Override důvodem, že třída redefinovala vlastnost s tímto řetězcem jako výchozí hodnotu.

"Base static        => $([BaseClass]::StaticProperty)"
"Derived static A   => $([DerivedClassA]::StaticProperty)"
"Derived static B   => $([DerivedClassB]::StaticProperty)"
"Derived static C   => $([DerivedClassC]::StaticProperty)"
"Derived static D   => $([DerivedClassD]::StaticProperty)"

Base static        => Static
Derived static A   => Static
Derived static B   => Static
Derived static C   => Static
Derived static D   => Override

S výjimkou DerivedClassD je hodnota statické vlastnosti pro odvozené třídy stejná jako základní třída, protože nepřeefinují vlastnost. To platí i pro DerivedClassC, který dědí z DerivedClassB místo přímo z BaseClass.

[DerivedClassA]::StaticProperty = 'Updated from A'
"Base static        => $([BaseClass]::StaticProperty)"
"Derived static A   => $([DerivedClassA]::StaticProperty)"
"Derived static B   => $([DerivedClassB]::StaticProperty)"
"Derived static C   => $([DerivedClassC]::StaticProperty)"
"Derived static D   => $([DerivedClassD]::StaticProperty)"

Base static        => Updated from A
Derived static A   => Updated from A
Derived static B   => Updated from A
Derived static C   => Updated from A
Derived static D   => Override

Pokud je staticProperty přístup a upraven prostřednictvím DerivedClassA, změněná hodnota ovlivní všechny třídy s výjimkou DerivedClassD.

Další informace o dědičnosti tříd, včetně komplexního příkladu, najdete v tématu about_Classes_Inheritance.

Použití atributů vlastností

PowerShell obsahuje několik tříd atributů, které můžete použít k vylepšení informací o datovém typu a ověření dat přiřazených k vlastnosti. Ověřovací atributy umožňují otestovat, že hodnoty zadané vlastnostmi splňují definované požadavky. Ověření se aktivuje v okamžiku, kdy je hodnota přiřazena.

Další informace o dostupnýchatributch about_Functions_Advanced_Parameters ch

Definování vlastností instance pomocí Update-TypeData

Kromě deklarování vlastností přímo v definici třídy můžete definovat vlastnosti pro instance třídy ve statickém konstruktoru pomocí rutiny Update-TypeData .

Tento fragment kódu použijte jako výchozí bod pro vzor. Podle potřeby nahraďte zástupný text v úhlových závorkách.

class <ClassName> {
    static [hashtable[]] $MemberDefinitions = @(
        @{
            MemberName = '<PropertyName>'
            MemberType = '<PropertyType>'
            Value      = <ValueDefinition>
        }
    )

    static <ClassName>() {
        $TypeName = [<ClassName>].Name
        foreach ($Definition in [<ClassName>]::MemberDefinitions) {
            Update-TypeData -TypeName $TypeName @Definition
        }
    }
}

Tip

Rutina Add-Member může přidat vlastnosti a metody do třídy v nestatického konstruktoru, ale rutina se spustí při každém zavolání konstruktoru. Použití Update-TypeData ve statickém konstruktoru zajišťuje, že kód pro přidání členů do třídy musí běžet pouze jednou v relaci.

Pouze přidat vlastnosti do třídy v nestatické konstruktory, pokud nelze definovat pomocí Update-TypeData, jako jsou vlastnosti jen pro čtení.

Definování vlastností aliasu

Atribut Alias nemá žádný vliv při použití na deklaraci vlastnosti třídy. PowerShell tento atribut používá pouze k definování aliasů pro názvy rutin, parametrů a funkcí.

Chcete-li definovat alias pro vlastnost třídy, použijte Update-TypeData s AliasPropertyMemberType.

Tato definice operablePair třídy například definuje dvě celočíselné vlastnosti x a y s aliasy LeftHandSide a RightHandSide v uvedeném pořadí.

class OperablePair {
    [int] $x
    [int] $y

    static [hashtable[]] $MemberDefinitions = @(
            @{
                MemberType = 'AliasProperty'
                MemberName = 'LeftHandSide'
                Value      = 'x'
            }
            @{
                MemberType = 'AliasProperty'
                MemberName = 'RightHandSide'
                Value      = 'y'
            }
    )

    static OperablePair() {
        $TypeName = [OperablePair].Name
        foreach ($Definition in [OperablePair]::MemberDefinitions) {
            Update-TypeData -TypeName $TypeName @Definition
        }
    }

    OperablePair() {}

    OperablePair([int]$x, [int]$y) {
        $this.x = $x
        $this.y = $y
    }

    # Math methods for the pair of values
    [int]   GetSum()        { return $this.x + $this.y }
    [int]   GetProduct()    { return $this.x * $this.y }
    [int]   GetDifference() { return $this.x - $this.y }
    [float] GetQuotient()   { return $this.x / $this.y }
    [int]   GetModulus()    { return $this.x % $this.y }
}

S definovanými aliasy mají uživatelé přístup k vlastnostem s některým názvem.

$pair = [OperablePair]@{ x = 8 ; RightHandSide = 3 }

"$($pair.x) % $($pair.y) = $($pair.GetModulus())"

$pair.LeftHandSide  = 3
$pair.RightHandSide = 2
"$($pair.x) x $($pair.y) = $($pair.GetProduct())"

8 % 3 = 2

3 x 2 = 6

Definování počítaných vlastností

Chcete-li definovat vlastnost, která odkazuje na hodnoty jiných vlastností, použijte rutinu Update-TypeDataScriptPropertys MemberType.

Tato definice třídy Rozpočet například definuje vlastnosti Výdaje a Výnosy jako pole čísel s plovoucí desetinou čárkou. Pomocí této rutiny Update-TypeData definuje počítané vlastnosti pro celkové výdaje, celkové výnosy a čistý příjem.

class Budget {
    [float[]] $Expenses
    [float[]] $Revenues

    static [hashtable[]] $MemberDefinitions = @(
        @{
            MemberType = 'ScriptProperty'
            MemberName = 'TotalExpenses'
            Value      = { ($this.Expenses | Measure-Object -Sum).Sum }
        }
        @{
            MemberType = 'ScriptProperty'
            MemberName = 'TotalRevenues'
            Value      = { ($this.Revenues | Measure-Object -Sum).Sum }
        }
        @{
            MemberType = 'ScriptProperty'
            MemberName = 'NetIncome'
            Value      = { $this.TotalRevenues - $this.TotalExpenses }
        }
    )

    static Budget() {
        $TypeName = [Budget].Name
        foreach ($Definition in [Budget]::MemberDefinitions) {
            Update-TypeData -TypeName $TypeName @Definition
        }
    }

    Budget() {}

    Budget($Expenses, $Revenues) {
        $this.Expenses = $Expenses
        $this.Revenues = $Revenues
    }
}

[Budget]::new()

[Budget]@{
    Expenses = @(2500, 1931, 3700)
    Revenues = @(2400, 2100, 4150)
}

TotalExpenses : 0
TotalRevenues : 0
NetIncome     : 0
Expenses      :
Revenues      :

TotalExpenses : 8131
TotalRevenues : 8650
NetIncome     : 519
Expenses      : {2500, 1931, 3700}
Revenues      : {2400, 2100, 4150}

Definování vlastností pomocí vlastní logiky get a set

Vlastnosti třídy PowerShellu nemůžou přímo definovat vlastní logiku getter a setter. Tuto funkci můžete odhadnout definováním backing vlastnosti s klíčovým slovem hidden a použitím Update-TypeData definovat viditelnou vlastnost s vlastní logikou pro získání a nastavení hodnoty.

Podle konvence definujte skrytý název backing vlastnosti s předponou podtržítka a použijte velbloudí velikostí. Například místo TaskCountpojmenujte skrytou záložní vlastnost _taskCount.

V tomto příkladu třída ProjectSize definuje skrytou celočíselnou vlastnost s názvem _value. Definuje hodnotu jako vlastní logiku ScriptProperty pro získání a nastavení vlastnosti _value. Setter scriptblock zpracovává převod řetězcové reprezentace projektu na správnou velikost.

class ProjectSize {
    hidden [ValidateSet(0, 1, 2, 3)] [int] $_value

    static [hashtable[]] $MemberDefinitions = @(
        @{
            MemberType  = 'ScriptProperty'
            MemberName  = 'Value'
            Value       = { $this._value } # Getter
            SecondValue = {                # Setter
                $ProposedValue = $args[0]

                if ($ProposedValue -is [string]) {
                    switch ($ProposedValue) {
                        'Small'  { $this._value = 1 ; break }
                        'Medium' { $this._value = 2 ; break }
                        'Large'  { $this._value = 3 ; break }
                        default  { throw "Unknown size '$ProposedValue'" }
                    }
                } else {
                    $this._value = $ProposedValue
                }
            }
        }
    )

    static ProjectSize() {
        $TypeName = [ProjectSize].Name
        foreach ($Definition in [ProjectSize]::MemberDefinitions) {
            Update-TypeData -TypeName $TypeName @Definition
        }
    }

    ProjectSize()              {}
    ProjectSize([int]$Size)    { $this.Value = $Size }
    ProjectSize([string]$Size) { $this.Value = $Size }

    [string] ToString() {
        $Output = switch ($this._value) {
            1       { 'Small'     }
            2       { 'Medium'    }
            3       { 'Large'     }
            default { 'Undefined' }
        }

        return $Output
    }
}

S definovaným vlastním getterem a setter můžete vlastnost Value nastavit jako celé číslo nebo řetězec.

$size = [ProjectSize]::new()
"The initial size is: $($size._value), $size"

$size.Value = 1
"The defined size is: $($size._value), $size"

$Size.Value += 1
"The updated size is: $($size._value), $size"

$Size.Value = 'Large'
"The final size is:   $($size._value), $size"

The initial size is: 0, Undefined

The defined size is: 1, Small

The updated size is: 2, Medium

The final size is:   3, Large

Omezení

Vlastnosti třídy PowerShellu mají následující omezení:

  • Statické vlastnosti jsou vždy proměnlivé. Třídy PowerShellu nemůžou definovat neměnné statické vlastnosti.

    Řešení: Žádné.

  • Vlastnosti nemohou použít atribut ValidateScript , protože argumenty atributu vlastnosti třídy musí být konstanty.

    Alternativní řešení: Definujte třídu, která dědí z typu ValidateArgumentsAttribute a místo toho tento atribut použijte.

  • Přímo deklarované vlastnosti nemohou definovat vlastní implementace getter a setter.

    Alternativní řešení: Definujte skrytou vlastnost a použijte Update-TypeData k definování viditelné logiky getter a setter.

  • Vlastnosti nemůžou použít atribut Alias . Atribut se vztahuje pouze na parametry, rutiny a funkce.

    Alternativní řešení: Pomocí rutiny Update-TypeData definujte aliasy v konstruktorech tříd.

  • Při převodu třídy PowerShellu ConvertTo-Json na JSON pomocí rutiny obsahuje výstupní JSON všechny skryté vlastnosti a jejich hodnoty.

    Řešení: Žádné

Viz také