about_Classes_Properties

Artikel
11/13/2023

Korte beschrijving

Hierin wordt beschreven hoe u eigenschappen definieert voor PowerShell-klassen.

Lange beschrijving

Eigenschappen zijn leden van de klasse die gegevens bevatten. Eigenschappen worden gedeclareerd als variabelen in het klassebereik. Een eigenschap kan van elk ingebouwd type of een exemplaar van een andere klasse zijn. Klassen kunnen nul of meer eigenschappen hebben. Klassen hebben geen maximumaantal eigenschappen.

Klasse-eigenschappen kunnen een willekeurig aantal kenmerken hebben, waaronder de verborgen en statische kenmerken. Elke eigenschapsdefinitie moet een type voor de eigenschap bevatten. U kunt een standaardwaarde voor een eigenschap definiëren.

Syntaxis

Klasse-eigenschappen gebruiken de volgende syntaxis:

Syntaxis van één regel

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

Syntaxis met meerdere regels

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

Voorbeelden

Voorbeeld 1: Minimale klasse-eigenschappen

De eigenschappen van de klasse ExampleProject1 maken gebruik van ingebouwde typen zonder kenmerken of standaardwaarden.

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

De standaardwaarde voor de eigenschappen Naam en Toegewezen gebruiker is $null omdat deze als tekenreeksen worden getypt. Dit is een verwijzingstype. De andere eigenschappen hebben de standaardwaarde voor het gedefinieerde type, omdat het eigenschappen van het waardetype zijn. Zie Standaardeigenschapswaarden voor meer informatie over de standaardwaarden voor eigenschappen.

Voorbeeld 2: Klasse-eigenschappen met aangepaste typen

De eigenschappen voor ExampleProject2 bevatten een aangepaste opsomming en klasse die is gedefinieerd in PowerShell vóór de klasse ExampleProject2 .

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

Voorbeeld 3: Klasse-eigenschap met een validatiekenmerk

De klasse ExampleProject3 definieert de eigenschap Grootte als een geheel getal dat groter dan of gelijk moet zijn aan 0 en kleiner dan of gelijk aan 16. Het kenmerk ValidateRange wordt gebruikt om de waarde te beperken.

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

Wanneer ExampleProject3 wordt geïnstitueert, wordt de grootte standaard ingesteld op 0. Als u de eigenschap instelt op een waarde binnen het geldige bereik, wordt de waarde bijgewerkt.

$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

Wanneer Grootte is ingesteld op een ongeldige waarde buiten het bereik, genereert PowerShell een uitzondering en wordt de waarde niet gewijzigd.

$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

Voorbeeld 4: Klasse-eigenschap met een expliciete standaardwaarde

In de klasse ExampleProject4 wordt de waarde voor de eigenschap StartDate standaard ingesteld op de huidige 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

Voorbeeld 5- Verborgen klasse-eigenschap

De guid-eigenschap van de klasse ExampleProject5 heeft het hidden trefwoord. De guid-eigenschap wordt niet weergegeven in de standaarduitvoer voor de klasse of in de lijst met eigenschappen die worden geretourneerd door 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;}

Voorbeeld 6- Statische klasse-eigenschap

De klasse ExampleProject6 definieert de eigenschap static Projects als een lijst met alle gemaakte projecten. De standaardconstructor voor de klasse voegt het nieuwe exemplaar toe aan de lijst met projecten.

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

Voorbeeld 7: een eigenschap definiëren in de constructor

De klasse ExampleProject7 definieert de eigenschap Duration-script in de statische klasseconstructor met de Update-TypeData cmdlet. Het gebruik van de Update-TypeData of Add-Member cmdlet is de enige manier om geavanceerde eigenschappen voor PowerShell-klassen te definiëren.

De eigenschap Duur retourneert een waarde van $null tenzij zowel de eigenschappen Begindatum als Einddatum zijn ingesteld en Begindatum is gedefinieerd dat deze eerder is dan de Einddatum.

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

De standaardweergave voor een exemplaar van de klasse ExampleProject7 bevat de duur. Omdat de eigenschappen Begindatum en Einddatum niet zijn ingesteld, is $nullde eigenschap Duur.

$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

Als de eigenschappen juist zijn ingesteld, retourneert de eigenschap Duur een periode die aangeeft hoe lang het project is uitgevoerd.

Standaardeigenschapswaarden

Elke klasse-eigenschap heeft een impliciete standaardwaarde, afhankelijk van het type eigenschap.

Als een eigenschap een verwijzingstype is, zoals een tekenreeks of een object, is $nullde impliciete standaardwaarde . Als een eigenschap een waardetype is, zoals een getal, Booleaanse waarde of opsomming, heeft de eigenschap een standaardwaarde, afhankelijk van het type:

Numerieke typen, zoals gehele getallen en getallen met drijvende komma, zijn standaard ingesteld op 0
Booleaanse waarden worden standaard ingesteld op $false
Opsommingen zijn standaard ingesteld 0op , zelfs de opsomming definieert geen label voor 0.

Zie Standaardwaarden van C#-typen (C#-verwijzing) voor meer informatie over standaardwaarden in .NET.

Als u een expliciete standaardwaarde voor een eigenschap wilt definiëren, declareert u de eigenschap met een toewijzing aan de standaardwaarde.

Deze definitie voor de Klasse ProjectTask definieert bijvoorbeeld een expliciete standaardwaarde voor de guid-eigenschap en wijst een willekeurige GUID toe aan elk nieuw exemplaar.

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

[ProjectTask]::new()

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

Verborgen en statische eigenschappen kunnen ook standaardwaarden hebben.

Verborgen eigenschappen

U kunt eigenschappen van een klasse verbergen door ze te declareren met het hidden trefwoord. Verborgen klasse-eigenschappen zijn:

Niet opgenomen in de standaarduitvoer voor de klasse.
Niet opgenomen in de lijst met klasseleden die door de Get-Member cmdlet worden geretourneerd. Als u verborgen eigenschappen wilt weergeven met Get-Member, gebruikt u de parameter Force .
Niet weergegeven in tabvoltooiing of IntelliSense, tenzij de voltooiing plaatsvindt in de klasse die de verborgen eigenschap definieert.
Openbare leden van de klas. Ze kunnen worden geopend en gewijzigd. Het verbergen van een eigenschap maakt het niet privé. De eigenschap wordt alleen verborgen zoals beschreven in de vorige punten.

Zie about_Hidden voor meer informatie over het hidden trefwoord.

Statische eigenschappen

U kunt een eigenschap definiëren als behorend tot de klasse zelf in plaats van exemplaren van de klasse door de eigenschap met het static trefwoord te declareren. Eigenschappen van statische klassen:

Zijn altijd beschikbaar, onafhankelijk van klasse-instantiëring.
Worden gedeeld in alle exemplaren van de klasse.
Zijn altijd beschikbaar.
Kunnen worden gewijzigd. Statische eigenschappen kunnen worden bijgewerkt. Ze zijn niet standaard onveranderbaar.
Live voor het hele sessiebereik.

Belangrijk

Statische eigenschappen voor klassen die zijn gedefinieerd in PowerShell zijn niet onveranderbaar. Ze kunnen

Eigenschappen van afgeleide klassen

Wanneer een klasse is afgeleid van een basisklasse, neemt deze de eigenschappen van de basisklasse over. Alle eigenschappen die zijn gedefinieerd op de basisklasse, inclusief verborgen eigenschappen, zijn beschikbaar in de afgeleide klasse.

Een afgeleide klasse kan een overgenomen eigenschap overschrijven door deze opnieuw te definiëren in de klassedefinitie. De eigenschap van de afgeleide klasse maakt gebruik van het opnieuw gedefinieerde type en de standaardwaarde, indien van toepassing. Als de overgenomen eigenschap een standaardwaarde heeft gedefinieerd en de opnieuw gedefinieerde eigenschap niet, heeft de overgenomen eigenschap geen standaardwaarde.

Als een afgeleide klasse geen statische eigenschap overschrijft, heeft toegang tot de statische eigenschap via de afgeleide klasse toegang tot de statische eigenschap van de basisklasse. Als u de eigenschapswaarde wijzigt via de afgeleide klasse, wordt de waarde op de basisklasse gewijzigd. Elke andere afgeleide klasse die de statische eigenschap niet overschrijft, gebruikt ook de waarde van de eigenschap op de basisklasse. Het bijwerken van de waarde van een overgenomen statische eigenschap in een klasse die de eigenschap niet overschrijft, heeft mogelijk onbedoelde effecten voor klassen die zijn afgeleid van dezelfde basisklasse.

In het volgende voorbeeld ziet u het gedrag voor statische eigenschappen en instantie-eigenschappen voor afgeleide 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

InstanceProperty voor DerivedClassC is een lege tekenreeks omdat de klasse de eigenschap opnieuw heeft gedefinieerd zonder een standaardwaarde in te stellen. Voor DerivedClassD is Override de waarde omdat de klasse de eigenschap met die tekenreeks opnieuw heeft gedefinieerd als de standaardwaarde.

"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

Met uitzondering van DerivedClassD is de waarde van de statische eigenschap voor de afgeleide klassen hetzelfde als de basisklasse, omdat ze de eigenschap niet opnieuw definiëren. Dit geldt zelfs voor DerivedClassC, die wordt overgenomen van DerivedClassB in plaats van rechtstreeks van 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

Wanneer StaticProperty wordt geopend en gewijzigd via DerivedClassA, is de gewijzigde waarde van invloed op elke klasse, met uitzondering van DerivedClassD.

Zie about_Classes_Inheritance voor meer informatie over overname van klassen, waaronder een uitgebreid voorbeeld.

Eigenschapskenmerken gebruiken

PowerShell bevat verschillende kenmerkklassen die u kunt gebruiken om gegevenstypegegevens te verbeteren en de gegevens te valideren die aan een eigenschap zijn toegewezen. Met validatiekenmerken kunt u testen of de waarden die aan eigenschappen zijn gegeven, voldoen aan gedefinieerde vereisten. Validatie wordt geactiveerd op het moment dat de waarde is toegewezen.

Zie about_Functions_Advanced_Parameters voor meer informatie over beschikbare kenmerken.

Exemplaareigenschappen definiëren met Update-TypeData

Naast het rechtstreeks declareren van eigenschappen in de klassedefinitie, kunt u eigenschappen definiëren voor exemplaren van een klasse in de statische constructor met behulp van de Update-TypeData cmdlet.

Gebruik dit fragment als uitgangspunt voor het patroon. Vervang indien nodig de tekst van de tijdelijke aanduiding tussen punthaken.

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

De Add-Member cmdlet kan eigenschappen en methoden toevoegen aan een klasse in niet-statische constructors, maar de cmdlet wordt elke keer uitgevoerd wanneer de constructor wordt aangeroepen. Het gebruik Update-TypeData in de statische constructor zorgt ervoor dat de code voor het toevoegen van de leden aan de klasse slechts eenmaal in een sessie hoeft te worden uitgevoerd.

Voeg alleen eigenschappen toe aan de klasse in niet-statische constructors wanneer ze niet kunnen worden gedefinieerd met Update-TypeData, zoals alleen-lezeneigenschappen.

Aliaseigenschappen definiëren

Het kenmerk Alias heeft geen effect wanneer het wordt gebruikt voor de declaratie van een klasse-eigenschap. PowerShell gebruikt dat kenmerk alleen om aliassen te definiëren voor cmdlet-, parameter- en functienamen.

Als u een alias voor een klasse-eigenschap wilt definiëren, gebruikt Update-TypeData u dit met het AliasPropertyMemberType.

Deze definitie van de klasse OperablePair definieert bijvoorbeeld twee gehele getallen x en y met respectievelijk de aliassen LeftHandSide en 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 }
}

Als de aliassen zijn gedefinieerd, hebben gebruikers toegang tot de eigenschappen met een van beide namen.

$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

Berekende eigenschappen definiëren

Als u een eigenschap wilt definiëren die verwijst naar de waarden van andere eigenschappen, gebruikt u de Update-TypeData cmdlet met het ScriptPropertyMemberType.

Deze definitie van de klasse Budget definieert bijvoorbeeld de eigenschappen Uitgaven en Inkomsten als matrices van drijvendekommagetallen. De cmdlet gebruikt de Update-TypeData cmdlet om berekende eigenschappen te definiëren voor de totale onkosten, de totale inkomsten en het netto-inkomen.

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}

Eigenschappen definiëren met aangepaste get- en setlogica

Eigenschappen van PowerShell-klassen kunnen geen aangepaste getter- en setterlogica rechtstreeks definiëren. U kunt deze functionaliteit benaderen door een back-upeigenschap te definiëren met het hidden trefwoord en een Update-TypeData zichtbare eigenschap te definiëren met aangepaste logica voor het ophalen en instellen van de waarde.

Definieer volgens de conventie de naam van de verborgen back-upeigenschap met een onderstrepingstekenvoorvoegsel en gebruik kameelbehuizing. Geef in plaats van TaskCountbijvoorbeeld de verborgen back-upeigenschap _taskCounteen naam.

In dit voorbeeld definieert de klasse ProjectSize een verborgen geheel getal met de naam _value. Deze definieert Waarde als een ScriptProperty met aangepaste logica voor het ophalen en instellen van de eigenschap _value. De setterscriptblock verwerkt het converteren van de tekenreeksweergave van het project naar de juiste grootte.

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

Als de aangepaste getter en setter zijn gedefinieerd, kunt u de eigenschap Waarde instellen als een geheel getal of tekenreeks.

$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

Beperkingen

Eigenschappen van PowerShell-klassen hebben de volgende beperkingen:

Statische eigenschappen zijn altijd veranderlijk. PowerShell-klassen kunnen geen onveranderbare statische eigenschappen definiëren.

Oplossing: Geen.
Eigenschappen kunnen het kenmerk ValidateScript niet gebruiken, omdat argumenten van het kenmerk klasse-eigenschap constanten moeten zijn.

Tijdelijke oplossing: Definieer een klasse die wordt overgenomen van het type ValidateArgumentsAttribute en gebruik dat kenmerk in plaats daarvan.
Rechtstreeks gedeclareerde eigenschappen kunnen geen aangepaste getter- en setter-implementaties definiëren.

Tijdelijke oplossing: definieer een verborgen eigenschap en gebruik Update-TypeData deze om de zichtbare getter- en setterlogica te definiëren.
Eigenschappen kunnen het aliaskenmerk niet gebruiken. Het kenmerk is alleen van toepassing op parameters, cmdlets en functies.

Tijdelijke oplossing: gebruik de Update-TypeData cmdlet om aliassen in de klasseconstructors te definiëren.
Wanneer een PowerShell-klasse wordt geconverteerd naar JSON met de ConvertTo-Json cmdlet, bevat de uitvoer-JSON alle verborgen eigenschappen en de bijbehorende waarden.

Oplossing: Geen

Delen via