Megosztás a következőn keresztül:

about_Classes_Properties

Rövid leírás

Ismerteti, hogyan definiálhat tulajdonságokat a PowerShell-osztályokhoz.

Hosszú leírás

A tulajdonságok az adatokat tartalmazó osztály tagjai. A tulajdonságok változóként vannak deklarálva az osztály hatókörében. A tulajdonság lehet bármilyen beépített típus vagy egy másik osztály példánya. Az osztályok nulla vagy több tulajdonságot tartalmazhatnak. Az osztályok nem rendelkeznek maximális tulajdonságszámokkal.

Az osztálytulajdonságok tetszőleges számú attribútummal rendelkezhetnek, beleértve a rejtett és statikus attribútumokat. Minden tulajdonságdefiníciónak tartalmaznia kell egy típust a tulajdonsághoz. Megadhat egy alapértelmezett értéket egy tulajdonsághoz.

Szemantika

Az osztálytulajdonságok a következő szintaxisokat használják:

Egysoros szintaxis

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

Többsoros szintaxis

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

Példák

1. példa – Minimális osztálytulajdonságok

Az ExampleProject1 osztály tulajdonságai attribútumok és alapértelmezett értékek nélkül használnak beépített típusokat.

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

A Név és Hozzárendelt tulajdonságainak alapértelmezett értéke $null, mert sztringekként vannak begépelve, ami hivatkozástípus. A többi tulajdonság a definiált típus alapértelmezett értékével rendelkezik, mivel értéktípus-tulajdonságok. További információ a tulajdonságok alapértelmezett értékéről: Alapértelmezett tulajdonságértékek.

2. példa – Osztálytulajdonságok egyéni típusokkal

Az ExampleProject2 tulajdonságai közé tartozik egy egyéni számbavétel és a PowerShellben az ExampleProject2 osztály előtt definiált osztály.

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

3. példa – Osztálytulajdonság érvényesítési attribútummal

Az ExampleProject3 osztály a Méret tulajdonságot 0-nál nagyobb vagy egyenlő egész számként határozza meg, és 16-nál kisebbnek vagy egyenlőnek kell lennie. Az érték korlátozásához a ValidateRange attribútumot használja.

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

Amikor ExampleProject3 példányt hoz létre, a Méret alapértelmezés szerint 0 lesz. Ha a tulajdonságot az érvényes tartományon belüli értékre állítja, az frissíti az értéket.

$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

Ha Méret tartományon kívüli értékre van állítva, a PowerShell kivételt hoz létre, és az érték nem változik.

$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

4. példa – Osztálytulajdonság explicit alapértelmezett értékkel

Az ExampleProject4 osztály alapértelmezés szerint az StartDate tulajdonság értékét az aktuális dátumig adja meg.

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

5. példa – Rejtett osztálytulajdonság

Az ExampleProject5 osztály Guid tulajdonsága hidden kulcsszóval rendelkezik. A Guid tulajdonság nem jelenik meg az osztály alapértelmezett kimenetében vagy a Get-Memberáltal visszaadott tulajdonságok listájában.

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;}

6. példa – Statikus osztálytulajdonság

A ExampleProject6 osztály az összes létrehozott projekt listájaként határozza meg a statikus Projektek tulajdonságot. Az osztály alapértelmezett konstruktora hozzáadja az új példányt a projektek listájához.

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

7. példa – Tulajdonság meghatározása a konstruktorban

Az ExampleProject7 osztály a parancsmaggal definiálja a statikus osztály konstruktorának Update-TypeData szkripttulajdonságát. Az Update-TypeData vagy Add-Member parancsmag használata az egyetlen módja annak, hogy speciális tulajdonságokat definiáljon a PowerShell-osztályokhoz.

Az Időtartam tulajdonság $null értéket ad vissza, kivéve, ha a StartDate és EndDate tulajdonság is be van állítva, és a StartDate az EndDatekorábbi értékre van definiálva.

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

Az ExampleProject7 osztály egy példányának alapértelmezett nézete tartalmazza az időtartamot. Mivel a StartDate és EndDate tulajdonság nincs beállítva, a Időtartam tulajdonság $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

Ha a tulajdonságok helyesen vannak beállítva, az Időtartam tulajdonság a projekt futási idejét jelző időbélyeget adja vissza.

Alapértelmezett tulajdonságértékek

Minden osztálytulajdonság implicit alapértelmezett értékkel rendelkezik a tulajdonság típusától függően.

Ha egy tulajdonság egy hivatkozástípus,, például sztring vagy objektum, akkor az implicit alapértelmezett érték $null. Ha egy tulajdonság egy típusú, például szám, logikai vagy enumerálás, a tulajdonság a típustól függően alapértelmezett értékkel rendelkezik:

  • Numerikus típusok, például egész számok és lebegőpontos számok, alapértelmezés szerint 0
  • A logikai értékek alapértelmezés szerint $false
  • Az enumerálások alapértelmezés szerint 0, még az enumerálás sem definiál címkét 0.

További információ a .NET alapértelmezett értékeiről: C# típusú alapértelmezett értékek (C#-referencia).

Ha explicit alapértelmezett értéket szeretne definiálni egy tulajdonsághoz, deklarálja a tulajdonságot az alapértelmezett értékhez való hozzárendeléssel.

A ProjectTask osztály definíciója például explicit alapértelmezett értéket határoz meg a Guid tulajdonsághoz, amely minden új példányhoz véletlenszerű GUID-t rendel.

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

[ProjectTask]::new()

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

A rejtett és statikus tulajdonságok alapértelmezett értékekkel is rendelkezhetnek.

Rejtett tulajdonságok

Az osztály tulajdonságait elrejtheti úgy, hogy deklarálja őket a hidden kulcsszóval. A rejtett osztálytulajdonságok a következők:

  • Nem szerepel az osztály alapértelmezett kimenetében.
  • A Get-Member parancsmag által visszaadott osztálytagok listájában nem szerepel. Ha rejtett tulajdonságokat szeretne megjeleníteni Get-Member, használja a Force paramétert.
  • Nem jelenik meg a tabulátorkizárásban vagy az IntelliSense-ben, kivéve, ha a befejezés a rejtett tulajdonságot meghatározó osztályban történik.
  • Az osztály nyilvános tagjai. Ezek elérhetők és módosíthatók. Egy tulajdonság elrejtése nem teszi privátsá. Csak az előző pontokban leírtak szerint rejti el a tulajdonságot.

A hidden kulcsszóval kapcsolatos további információkért lásd: about_Hidden.

Statikus tulajdonságok

A tulajdonságot az osztály példányai helyett úgy határozhatja meg, hogy a tulajdonságot static kulcsszóval deklarálja. Statikus osztály tulajdonságai:

  • Mindig elérhetőek, az osztály példányosításától függetlenül.
  • Az osztály összes példánya meg van osztva.
  • Mindig elérhetőek.
  • Módosíthatók. A statikus tulajdonságok frissíthetők. Alapértelmezés szerint nem módosíthatók.
  • Élőben a teljes munkamenethez.

Fontos

A PowerShellben definiált osztályok statikus tulajdonságai nem módosíthatók. A statikus tulajdonság típusa és attribútumai által meghatározott bármely érvényes értékre felül lehet bírálni őket.

Származtatott osztálytulajdonságok

Amikor egy osztály egy alaposztályból származik, az örökli az alaposztály tulajdonságait. Az alaposztályon definiált tulajdonságok, beleértve a rejtett tulajdonságokat is, elérhetők a származtatott osztályban.

A származtatott osztályok felülbírálhatnak egy örökölt tulajdonságot, ha újradefiniálják azt az osztálydefinícióban. A származtatott osztály tulajdonsága az újradefiniált típust és az alapértelmezett értéket használja, ha van ilyen. Ha az örökölt tulajdonság alapértelmezett értéket definiált, és az újradefiniált tulajdonság nem, az örökölt tulajdonság nem rendelkezik alapértelmezett értékkel.

Ha egy származtatott osztály nem felülbírál egy statikus tulajdonságot, a származtatott osztályon keresztül elért statikus tulajdonság az alaposztály statikus tulajdonságához fér hozzá. A tulajdonságérték származtatott osztályon keresztül történő módosítása módosítja az alaposztály értékét. Minden más származtatott osztály, amely nem bírálja felül a statikus tulajdonságot, az alaposztály tulajdonságának értékét is használja. Az örökölt statikus tulajdonság értékének frissítése olyan osztályban, amely nem bírálja felül a tulajdonságot, előfordulhat, hogy az azonos alaposztályból származó osztályokra nem tervezett hatással van.

Az alábbi példa a származtatott osztályok statikus és példánytulajdonságainak viselkedését mutatja be.

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

Az InstancePropertyDerivedClassC egy üres sztring, mert az osztály alapértelmezett érték megadása nélkül újradefiniálta a tulajdonságot. DerivedClassD az érték Override, mert az osztály az alapértelmezett értékként újradefiniálta a tulajdonságot ezzel a sztringgel.

"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

Az DerivedClassDkivételével a származtatott osztályok statikus tulajdonságának értéke megegyezik az alaposztály értékével, mivel nem definiálják újra a tulajdonságot. Ez még az DerivedClassCis vonatkozik, amely DerivedClassB örökli ahelyett, hogy közvetlenül 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

Ha StaticPropertyDerivedClassAkeresztül érhető el és módosul, a módosított érték minden osztályra hatással van, kivéve DerivedClassD.

További információ az osztályöröklésről, beleértve egy átfogó példát is, lásd: about_Classes_Inheritance.

Tulajdonságattribútumok használata

A PowerShell számos attribútumosztályt tartalmaz, amelyekkel javíthatja az adattípus-információkat, és ellenőrizheti a tulajdonsághoz rendelt adatokat. Az érvényesítési attribútumok lehetővé teszik annak tesztelését, hogy a tulajdonságoknak adott értékek megfelelnek-e a meghatározott követelményeknek. Az érvényesítés az érték hozzárendelésének pillanatában aktiválódik.

Az elérhető attribútumokról további információt a about_Functions_Advanced_Parameterscímű témakörben talál.

Példánytulajdonságok definiálása Update-TypeData

A tulajdonságok közvetlenül az osztálydefinícióban való deklarálásán túl a statikus konstruktor osztálypéldányainak tulajdonságait is meghatározhatja a Update-TypeData parancsmaggal.

Használja ezt a kódrészletet a minta kiindulópontjaként. Szükség szerint cserélje le a helyőrző szöveget szögletes zárójelekben.

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
        }
    }
}

Borravaló

A Add-Member parancsmag tulajdonságokat és metódusokat adhat hozzá a nem statikus konstruktorok osztályaihoz, de a parancsmag minden alkalommal fut, amikor a konstruktort meghívják. A Update-TypeData statikus konstruktorban való használata biztosítja, hogy a tagok osztályhoz való hozzáadásához használt kódnak csak egyszer kell futnia egy munkamenetben.

Csak akkor adjon hozzá tulajdonságokat az osztályhoz nem statikus konstruktorokban, ha nem definiálhatók Update-TypeData, például írásvédett tulajdonságokkal.

Aliastulajdonságok meghatározása

Az Alias attribútumnak nincs hatása az osztálytulajdonság-deklarációban való használatkor. A PowerShell csak ezt az attribútumot használja a parancsmagok, paraméterek és függvénynevek aliasainak definiálásához.

Egy osztálytulajdonság aliasának definiálásához használja a Update-TypeData a AliasPropertyMemberType.

Az OperablePair osztály ezen definíciója például két egész tulajdonságot határoz meg, x és yLeftHandSide és RightHandSide aliasokkal.

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 }
}

A definiált aliasokkal a felhasználók bármelyik névvel hozzáférhetnek a tulajdonságokhoz.

$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

Számított tulajdonságok meghatározása

Ha más tulajdonságok értékeire hivatkozó tulajdonságot szeretne definiálni, használja a Update-TypeData parancsmagot a ScriptPropertyMemberType.

A Költségvetési osztály ezen definíciója például lebegőpontos számok tömbjeként határozza meg a Kiadási és Bevételek tulajdonságokat. A Update-TypeData parancsmag használatával határozza meg a teljes kiadás, a teljes bevétel és a nettó bevétel számított tulajdonságait.

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}

Tulajdonságok definiálása egyéni beolvasással és logikai beállítással

A PowerShell-osztály tulajdonságai nem definiálhatnak közvetlenül egyéni getter- és setter-logikát. Ezt a funkciót úgy közelítheti meg, hogy definiál egy háttértulajdonságot a hidden kulcsszóval, és a Update-TypeData használatával definiál egy látható tulajdonságot egyéni logikával az érték lekéréséhez és beállításához.

Konvenció szerint definiálja a rejtett háttértulajdonság nevét aláhúzásjeles előtaggal, és használjon teveházat. Például a TaskCounthelyett adja a rejtett háttértulajdonságnak _taskCount.

Ebben a példában a ProjectSize osztály egy rejtett egész szám tulajdonságot határoz meg _value. A Value egyéni logikával rendelkező ScriptProperty definiálja a _value tulajdonság beolvasásához és beállításához. A setter scriptblock kezeli a projekt sztringképének megfelelő méretre konvertálását.

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
    }
}

Az egyéni getter és a setter definiálva az Value tulajdonságot egész számként vagy sztringként is beállíthatja.

$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

Korlátozások

A PowerShell-osztály tulajdonságai a következő korlátozásokkal rendelkeznek:

  • A statikus tulajdonságok mindig változékonyak. A PowerShell-osztályok nem definiálhatnak nem módosítható statikus tulajdonságokat.

    Megkerülő megoldás: Nincs.

  • A tulajdonságok nem használhatják a ValidateScript attribútumot, mert az osztálytulajdonság-attribútum argumentumainak állandóknak kell lenniük.

    Megkerülő megoldás: Definiáljon egy osztályt, amely a ValidateArgumentsAttribute típusától örököl, és használja inkább ezt az attribútumot.

  • A közvetlenül deklarált tulajdonságok nem definiálhatnak egyéni getter- és setter-implementációkat.

    Megkerülő megoldás: Definiáljon egy rejtett tulajdonságot, és használja a Update-TypeData a látható getter és a setter logika definiálásához.

  • A tulajdonságok nem használhatják a Alias attribútumot. Az attribútum csak paraméterekre, parancsmagokra és függvényekre vonatkozik.

    Megkerülő megoldás: Az Update-TypeData parancsmaggal definiálhat aliasokat az osztálykonstruktorokban.

  • Ha egy PowerShell-osztály JSON-ra van konvertálva a ConvertTo-Json parancsmaggal, a kimeneti JSON tartalmazza az összes rejtett tulajdonságot és azok értékeit.

    Megkerülő megoldás: Nincs

Lásd még

  • Last updated on