about_Classes_Properties

Artykuł
11/13/2023

Krótki opis

Opisuje sposób definiowania właściwości dla klas programu PowerShell.

Długi opis

Właściwości to składowe klasy zawierającej dane. Właściwości są deklarowane jako zmienne w zakresie klasy. Właściwość może mieć dowolny typ wbudowany lub wystąpienie innej klasy. Klasy mogą zawierać zero lub więcej właściwości. Klasy nie mają maksymalnej liczby właściwości.

Właściwości klasy mogą mieć dowolną liczbę atrybutów, w tym atrybuty ukryte i statyczne . Każda definicja właściwości musi zawierać typ właściwości. Można zdefiniować wartość domyślną dla właściwości.

Składnia

Właściwości klasy używają następujących składni:

Składnia jednowierszowa

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

Składnia wielowierszowa

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

Przykłady

Przykład 1 — minimalne właściwości klasy

Właściwości klasy ExampleProject1 używają typów wbudowanych bez żadnych atrybutów ani wartości domyślnych.

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

Wartością domyślną właściwości Name i Assignee jest $null to, że są one wpisywane jako ciągi, czyli typ odwołania. Inne właściwości mają wartość domyślną dla zdefiniowanego typu, ponieważ są właściwościami typu wartości. Aby uzyskać więcej informacji na temat wartości domyślnych właściwości, zobacz Domyślne wartości właściwości.

Przykład 2 — właściwości klasy z typami niestandardowymi

Właściwości elementu ExampleProject2 obejmują niestandardową wyliczenie i klasę zdefiniowaną w programie PowerShell przed klasą 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

Przykład 3 — właściwość klasy z atrybutem weryfikacji

Klasa ExampleProject3 definiuje właściwość Size jako liczbę całkowitą, która musi być większa lub równa 0 i mniejsza lub równa 16. Używa atrybutu ValidateRange , aby ograniczyć wartość.

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

Gdy wystąpi wystąpienie ExampleProject3, wartość domyślna rozmiaru to 0. Ustawienie właściwości na wartość w prawidłowym zakresie powoduje zaktualizowanie wartości.

$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

Gdy właściwość Size jest ustawiona na nieprawidłową wartość poza zakresem, program PowerShell zgłasza wyjątek i wartość nie zostanie zmieniona.

$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

Przykład 4 — właściwość Klasy z jawną wartością domyślną

Klasa ExampleProject4 domyślnie ustawia wartość właściwości StartDate na bieżącą datę.

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

Przykład 5 — właściwość klasy ukrytej

Właściwość Guid klasy ExampleProject5 ma hidden słowo kluczowe . Właściwość Guid nie jest wyświetlana w domyślnych danych wyjściowych klasy ani na liście właściwości zwracanych przez Get-Memberelement .

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

Przykład 6 — właściwość klasy statycznej

Klasa ExampleProject6 definiuje właściwość static Projects jako listę wszystkich utworzonych projektów. Domyślny konstruktor klasy dodaje nowe wystąpienie do listy projektów.

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

Przykład 7 — definiowanie właściwości w konstruktorze

Klasa ExampleProject7 definiuje właściwość skryptu Duration w konstruktorze klasy statycznej za pomocą Update-TypeData polecenia cmdlet . Użycie polecenia Update-TypeData cmdlet lub Add-Member to jedyny sposób definiowania zaawansowanych właściwości dla klas programu PowerShell.

Właściwość Duration zwraca wartość , $null chyba że ustawiono zarówno właściwości StartDate, jak i EndDate, a właściwość StartDate jest zdefiniowana jako wcześniejsza niż Data zakończenia.

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

Widok domyślny dla wystąpienia klasy ExampleProject7 obejmuje czas trwania. Ponieważ właściwości StartDate i EndDate nie są ustawione, właściwość Duration ma wartość $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

Po poprawnym ustawieniu właściwości Duration właściwość Duration zwraca przedział czasu reprezentujący czas uruchomienia projektu.

Domyślne wartości właściwości

Każda właściwość klasy ma niejawną wartość domyślną w zależności od typu właściwości.

Jeśli właściwość jest typem odwołania, na przykład ciągiem lub obiektem, niejawna wartość domyślna to $null. Jeśli właściwość jest typem wartości, na przykład liczba, wartość logiczna lub wyliczenie, właściwość ma wartość domyślną w zależności od typu:

Typy liczbowe, takie jak liczby całkowite i liczby zmiennoprzecinkowe, domyślnie to 0
Wartości logiczne są domyślnie ustawione na $false
Wartości domyślne wyliczenia to 0, nawet wyliczenie nie definiuje etykiety dla elementu 0.

Aby uzyskać więcej informacji na temat wartości domyślnych na platformie .NET, zobacz Domyślne wartości typów języka C# (odwołanie w C#).

Aby zdefiniować jawną wartość domyślną dla właściwości, zadeklaruj właściwość przy użyciu przypisania do wartości domyślnej.

Na przykład ta definicja klasy ProjectTask definiuje jawną wartość domyślną dla właściwości Guid, przypisując losowy identyfikator GUID do każdego nowego wystąpienia.

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

[ProjectTask]::new()

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

Ukryte i statyczne właściwości mogą również mieć wartości domyślne.

Ukryte właściwości

Właściwości klasy można ukryć, deklarując je za pomocą słowa kluczowego hidden . Ukryte właściwości klasy to:

Nieuwzględniane w domyślnych danych wyjściowych klasy.
Nieuwzględniane na liście składowych klas zwracanych przez Get-Member polecenie cmdlet. Aby wyświetlić ukryte właściwości za pomocą Get-Memberpolecenia , użyj parametru Force .
Nie są wyświetlane w uzupełnianiu tabulatora lub funkcji IntelliSense, chyba że ukończenie występuje w klasie definiującej właściwość ukrytą.
Publiczne elementy członkowskie klasy. Dostęp do nich można uzyskać i zmodyfikować. Ukrywanie właściwości nie powoduje, że jest ona prywatna. Ukrywa tylko właściwość zgodnie z opisem w poprzednich punktach.

Aby uzyskać więcej informacji na temat słowa kluczowego hidden , zobacz about_Hidden.

Właściwości statyczne

Właściwość można zdefiniować jako należącą do samej klasy zamiast wystąpień klasy, deklarując właściwość za pomocą słowa kluczowego static . Właściwości klasy statycznej:

Są zawsze dostępne, niezależne od wystąpienia klas.
Są współużytkowane we wszystkich wystąpieniach klasy.
Są zawsze dostępne.
Można modyfikować. Właściwości statyczne można zaktualizować. Nie są one domyślnie niezmienne.
Na żywo dla całego zakresu sesji.

Ważne

Właściwości statyczne dla klas zdefiniowanych w programie PowerShell nie są niezmienne. Mogą

Właściwości klasy pochodnej

Gdy klasa pochodzi z klasy bazowej, dziedziczy właściwości klasy bazowej. Wszystkie właściwości zdefiniowane w klasie bazowej, w tym ukryte właściwości, są dostępne w klasie pochodnej.

Klasa pochodna może zastąpić dziedziczona właściwość, ponownie definiując ją w definicji klasy. Właściwość klasy pochodnej używa ponownie zdefiniowanego typu i wartości domyślnej, jeśli istnieje. Jeśli dziedziczona właściwość zdefiniowała wartość domyślną, a właściwość ponownie zdefiniowana nie, dziedziczona właściwość nie ma wartości domyślnej.

Jeśli klasa pochodna nie zastępuje właściwości statycznej, uzyskiwanie dostępu do właściwości statycznej za pośrednictwem klasy pochodnej uzyskuje dostęp do właściwości statycznej klasy bazowej. Modyfikowanie wartości właściwości za pomocą klasy pochodnej modyfikuje wartość w klasie bazowej. Każda inna klasa pochodna, która nie zastępuje właściwości statycznej, używa również wartości właściwości w klasie bazowej. Aktualizowanie wartości odziedziczonej właściwości statycznej w klasie, która nie zastępuje właściwości, może mieć niezamierzone efekty dla klas pochodnych z tej samej klasy bazowej.

W poniższym przykładzie pokazano zachowanie właściwości statycznych i wystąpień dla klas pochodnych.

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

Właściwość InstanceProperty dla klasy DerivedClassC jest pustym ciągiem, ponieważ klasa ponownie zdefiniowała właściwość bez ustawiania wartości domyślnej. W przypadku klasy DerivedClassD wartość jest Override taka, ponieważ klasa ponownie zdefiniowała właściwość z tym ciągiem jako wartość domyślną.

"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

Z wyjątkiem klasy DerivedClassD wartość właściwości statycznej dla klas pochodnych jest taka sama jak klasa bazowa, ponieważ nie definiują ponownie właściwości. Dotyczy to nawet klasy DerivedClassC, która dziedziczy z klasy DerivedClassB zamiast bezpośrednio z klasy 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

Gdy dostęp do właściwości StaticProperty jest uzyskiwany i modyfikowany za pośrednictwem klasy DerivedClassA, zmieniona wartość wpływa na każdą klasę z wyjątkiem klasy DerivedClassD.

Aby uzyskać więcej informacji na temat dziedziczenia klas, w tym kompleksowy przykład, zobacz about_Classes_Inheritance.

Używanie atrybutów właściwości

Program PowerShell zawiera kilka klas atrybutów, których można użyć do ulepszania informacji o typie danych i sprawdzania poprawności danych przypisanych do właściwości. Atrybuty weryfikacji umożliwiają przetestowanie, czy wartości podane właściwości spełniają zdefiniowane wymagania. Walidacja jest wyzwalana w momencie przypisania wartości.

Aby uzyskać więcej informacji na temat dostępnych atrybutów, zobacz about_Functions_Advanced_Parameters.

Definiowanie właściwości wystąpienia za pomocą właściwości Update-TypeData

Poza deklarowaniem właściwości bezpośrednio w definicji klasy można zdefiniować właściwości dla wystąpień klasy w konstruktorze statycznym przy użyciu Update-TypeData polecenia cmdlet .

Użyj tego fragmentu kodu jako punktu wyjścia dla wzorca. Zastąp tekst zastępczy w nawiasach kątowych zgodnie z potrzebami.

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

Napiwek

Polecenie Add-Member cmdlet może dodawać właściwości i metody do klasy w konstruktorach niestacjonanych, ale polecenie cmdlet jest uruchamiane za każdym razem, gdy konstruktor jest wywoływany. Użycie Update-TypeData w konstruktorze statycznym gwarantuje, że kod dodawania składowych do klasy musi być uruchamiany tylko raz w sesji.

Dodaj właściwości tylko do klasy w konstruktorach niestacjonanych, gdy nie można ich zdefiniować za pomocą Update-TypeDatawłaściwości , takich jak właściwości tylko do odczytu.

Definiowanie właściwości aliasu

Atrybut Alias nie ma wpływu na deklarację właściwości klasy. Program PowerShell używa tylko tego atrybutu do definiowania aliasów dla poleceń cmdlet, parametrów i nazw funkcji.

Aby zdefiniować alias dla właściwości klasy, użyj właściwości Update-TypeDataAliasPropertyMemberType.

Na przykład ta definicja klasy OperablePair definiuje dwie właściwości całkowite x i y z aliasami LeftHandSide i RightHandSide odpowiednio.

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

Po zdefiniowaniu aliasów użytkownicy mogą uzyskiwać dostęp do właściwości z jedną z nazw.

$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

Definiowanie właściwości obliczeniowych

Aby zdefiniować właściwość odwołującą się do wartości innych właściwości, użyj Update-TypeData polecenia cmdlet z właściwością ScriptPropertyMemberType.

Na przykład ta definicja klasy Budget definiuje właściwości Wydatki i Przychody jako tablice liczb zmiennoprzecinkowych. Używa Update-TypeData polecenia cmdlet do definiowania właściwości obliczeniowych dla całkowitych wydatków, całkowitych przychodów i dochodu netto.

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}

Definiowanie właściwości za pomocą niestandardowej logiki pobierania i ustawiania

Właściwości klasy programu PowerShell nie mogą bezpośrednio definiować niestandardowego modułu pobierania i logiki ustawiającej. Można przybliżyć tę funkcję, definiując właściwość tworzenia kopii zapasowej za pomocą słowa kluczowego hidden i definiując Update-TypeData widoczną właściwość z niestandardową logiką pobierania i ustawiania wartości.

Zgodnie z konwencją zdefiniuj ukrytą nazwę właściwości kopii zapasowej z prefiksem podkreślenia i użyj wielkości liter wielbłąda. Na przykład zamiast nazwy , nadaj TaskCountukrytej właściwości _taskCountkopii zapasowej .

W tym przykładzie klasa ProjectSize definiuje ukrytą właściwość całkowitą o nazwie _value. Definiuje wartość jako element z niestandardową logiką ScriptProperty pobierania i ustawiania właściwości _value . Blok skryptu ustawiającego obsługuje konwertowanie reprezentacji ciągu projektu na poprawny rozmiar.

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

Po zdefiniowaniu niestandardowego modułu pobierającego i ustawiającego można ustawić właściwość Value jako liczbę całkowitą lub ciąg.

$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

Ograniczenia

Właściwości klasy programu PowerShell mają następujące ograniczenia:

Właściwości statyczne są zawsze modyfikowalne. Klasy programu PowerShell nie mogą definiować niezmiennych właściwości statycznych.

Obejście: brak.
Właściwości nie mogą używać atrybutu ValidateScript , ponieważ argumenty atrybutu właściwości klasy muszą być stałe.

Obejście: Zdefiniuj klasę dziedziczą z typu ValidateArgumentsAttribute i użyj tego atrybutu.
Właściwości zadeklarowane bezpośrednio nie mogą definiować niestandardowych implementacji getter i setter.

Obejście: Zdefiniuj właściwość ukrytą i użyj polecenia Update-TypeData , aby zdefiniować widoczną logikę pobierania i ustawiania.
Właściwości nie mogą używać atrybutu Alias . Atrybut dotyczy tylko parametrów, poleceń cmdlet i funkcji.

Obejście: Użyj Update-TypeData polecenia cmdlet, aby zdefiniować aliasy w konstruktorach klas.
Po przekonwertowaniu klasy programu PowerShell na kod JSON za ConvertTo-Json pomocą polecenia cmdlet dane wyjściowe JSON zawierają wszystkie ukryte właściwości i ich wartości.

Obejście: brak