about_Classes_Properties

  • Cikk

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 is. Minden tulajdonságdefiníciónak tartalmaznia kell egy típust a tulajdonsághoz. Megadhat egy alapértelmezett értéket egy tulajdonsághoz.

Syntax

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árendelés tulajdonságainak alapértelmezett értéke az$null, hogy 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. A tulajdonságok alapértelmezett értékeiről további információt az Alapértelmezett tulajdonságértékek című témakörben talál.

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 Size tulajdonságot egész számként határozza meg, amely 0-nál nagyobb vagy egyenlő, 16-nál kisebb vagy egyenlő lehet. Az ValidateRange attribútummal korlátozza az értéket.

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 az ExampleProject3 példányosít, 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 a méret a tartományon kívüli érvénytelen é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

A ExampleProject4 osztály alapértelmezés szerint a StartDate tulajdonság értékét az aktuális dátumra számítja .

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 a hidden kulcsszó. A Guid tulajdonság nem jelenik meg az osztály alapértelmezett kimenetében vagy a visszaadott Get-Membertulajdonsá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

Az ExampleProject6 osztály a statikus Projektek tulajdonságot az összes létrehozott projekt listájaként határozza meg. 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 Update-TypeData definiálja a statikus osztály konstruktorának Duration szkript tulajdonságát. A PowerShell-osztályok speciális tulajdonságai csak a parancsmag vagy Add-Member a Update-TypeData parancsmag használatával határozhatók meg.

Az Időtartam tulajdonság csak akkor ad vissza értéket$null, ha a StartDate és az EndDate tulajdonság is be van állítva, a StartDate pedig az EndDate-nél korá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 az EndDate tulajdonság nincs beállítva, az Duration tulajdonság az $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 Duration tulajdonság egy időbélyeget ad vissza, amely a projekt futási idejét jelzi.

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 hivatkozástípus, például sztring vagy objektum, az implicit alapértelmezett érték.$null Ha egy tulajdonság értéktí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 a következő: 0
  • Logikai értékek alapértelmezett értéke: $false
  • Az enumerálások alapértelmezett értéke0, még az enumerálás sem határoz meg címkét.0

A .NET alapértelmezett értékeivel kapcsolatos további információkért lásd : 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 egy explicit alapértelmezett értéket határoz meg a Guid tulajdonsághoz, amely véletlenszerű GUID-azonosítót rendel minden új példányhoz.

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 a kulcsszóval deklarálja őket hidden . A rejtett osztálytulajdonságok a következők:

  • Nem szerepel az osztály alapértelmezett kimenetében.
  • A parancsmag által Get-Member visszaadott osztálytagok listájában nem szerepel. A rejtett tulajdonságok Get-Membermegjelenítéséhez 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 kulcsszóval kapcsolatos további információkért lásd: hidden about_Hidden.

Statikus tulajdonságok

A tulajdonságot az osztály példányai helyett az osztályhoz tartozóként definiálhatja úgy, hogy a tulajdonságot a 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

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 InstanceProperty for DerivedClassC egy üres sztring, mert az osztály az alapértelmezett érték megadása nélkül újradefiniálta a tulajdonságot. A DerivedClassD esetében az érték az, Override hogy az osztály újradefiniálta a tulajdonságot ezzel a sztringgel alapértelmezett értékként.

"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

A Származtatott osztály kivé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 a DerivedClassC-ra is vonatkozik, amely a DerivedClassB-tőlörökli ahelyett, hogy közvetlenül a BaseClass-ból származik.

[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 a StaticProperty a DerivedClassA-on keresztül érhető el és módosul, a módosított érték a DerivedClassD kivételével minden osztályra hatással van.

Az osztályöröklődéssel kapcsolatos további információkért, beleértve egy átfogó példát, tekintse meg a 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_Parameters című témakörben talál.

Példánytulajdonságok definiálása az Update-TypeData használatával

A tulajdonságok közvetlenül az osztálydefinícióban való deklarálásán túl a parancsmag használatával Update-TypeData definiálhat tulajdonságokat egy osztály példányaihoz a statikus konstruktorban.

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

Tipp.

A Add-Member parancsmag tulajdonságokat és metódusokat adhat hozzá egy osztályhoz nem statikus konstruktorokban, de a parancsmag minden alkalommal fut, amikor a konstruktort meghívják. A Update-TypeData statikus konstruktor 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 határozhatók meg Update-TypeDatapé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 Update-TypeData a AliasPropertyMemberType tulajdonságot.

Az OperablePair osztály ezen definíciója például két x és y egész tulajdonságot határoz meg a LeftHandSide és a 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 membertype parancsmagotScriptProperty.

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ások és bevételek tulajdonságokat. A parancsmagot használja a teljes költségek, a teljes bevétel és a Update-TypeData nettó bevétel számított tulajdonságainak meghatározására.

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 Update-TypeData egy látható tulajdonságot definiál 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. A rejtett háttértulajdonság helyett TaskCountpéldául nevezze el a rejtett háttértulajdonságot _taskCount.

Ebben a példában a ProjectSize osztály egy _value nevű rejtett egész számtulajdonságot határoz meg. Az értékeket egyéni logikával definiálja a _value tulajdonság lekéréséhez és beállításához.ScriptProperty 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 Érték 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ípustó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 definiálja Update-TypeData a látható getter és a setter logikát.

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

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

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

    Megkerülő megoldás: Nincs

Lásd még