about_Classes_Properties
Kort beskrivning
Beskriver hur du definierar egenskaper för PowerShell-klasser.
Lång beskrivning
Egenskaper är medlemmar i klassen som innehåller data. Egenskaper deklareras som variabler i klassomfånget. En egenskap kan vara av valfri inbyggd typ eller en instans av en annan klass. Klasser kan noll eller fler egenskaper. Klasser har inte ett maximalt antal egenskaper.
Klassegenskaper kan ha valfritt antal attribut, inklusive dolda och statiska attribut. Varje egenskapsdefinition måste innehålla en typ för egenskapen. Du kan definiera ett standardvärde för en egenskap.
Syntax
Klassegenskaper använder följande syntaxer:
Enradssyntax
[[<attribute>]...] [<property-type>] $<property-name> [= <default-value>]
Syntax för flera linjer
[[<attribute>]...]
[<property-type>]
$<property-name> [= <default-value>]
Exempel
Exempel 1 – Minimala klassegenskaper
Egenskaperna för klassen ExampleProject1 använder inbyggda typer utan attribut eller standardvärden.
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
Standardvärdet för egenskaperna Namn och Tilldelad är $null att de skrivs som strängar, vilket är en referenstyp. De andra egenskaperna har standardvärdet för sin definierade typ, eftersom de är värdetypsegenskaper. Mer information om standardvärdena för egenskaper finns i Standardegenskapsvärden.
Exempel 2 – Klassegenskaper med anpassade typer
Egenskaperna för ExampleProject2 innehåller en anpassad uppräkning och klass som definierats i PowerShell före klassen 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
Exempel 3 – Klassegenskap med ett valideringsattribut
Klassen ExampleProject3 definierar egenskapen Storlek som ett heltal som måste vara större än eller lika med 0 och mindre än eller lika med 16. Attributet ValidateRange används för att begränsa värdet.
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
När ExampleProject3 instansierar är storleken standard 0. Om du anger egenskapen till ett värde inom det giltiga intervallet uppdateras värdet.
$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
När Storlek är inställt på ett ogiltigt värde utanför intervallet genererar PowerShell ett undantag och värdet ändras inte.
$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
Exempel 4 – Klassegenskap med ett explicit standardvärde
Klassen ExampleProject4 är standardvärdet för egenskapen StartDate till det aktuella datumet.
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
Exempel 5 – Dold klassegenskap
Guid-egenskapen för klassen ExampleProject5 har nyckelordet hidden . Guid-egenskapen visas inte i standardutdata för klassen eller i listan över egenskaper som returneras av 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;}
Exempel 6 – Egenskap för statisk klass
Klassen ExampleProject6 definierar egenskapen static Projects som en lista över alla projekt som skapats. Standardkonstruktorn för klassen lägger till den nya instansen i listan över projekt.
class ExampleProject6 {
[string] $Name
[int] $Size
[bool] $Completed
[string] $Assignee
[datetime] $StartDate
[datetime] $EndDate
[datetime] $DueDate
hidden [string] $Guid = (New-Guid).Guid
static [ExampleProject6[]] $Projects = @()
ExampleProject6() {
[ExampleProject6]::Projects += $this
}
}
"Project Count: $([ExampleProject6]::Projects.Count)"
$project1 = [ExampleProject6]@{ Name = 'Project_1' }
$project2 = [ExampleProject6]@{ Name = 'Project_2' }
[ExampleProject6]::Projects | Select-Object -Property Name, Guid
Project Count: 0
Name Guid
---- ----
Project_1 75e7c8a0-f8d1-433a-a5be-fd7249494694
Project_2 6c501be4-e68c-4df5-8fce-e49dd8366afe
Exempel 7 – Definiera en egenskap i konstruktorn
Klassen ExampleProject7 definierar egenskapen Varaktighetsskript i konstruktorn för statisk klass med cmdleten Update-TypeData . Att använda cmdleten Update-TypeData eller Add-Member är det enda sättet att definiera avancerade egenskaper för PowerShell-klasser.
Egenskapen Duration returnerar värdet $null om inte både egenskaperna StartDate och EndDate anges och StartDate definieras som tidigare än EndDate.
class ExampleProject7 {
[string] $Name
[int] $Size
[bool] $Completed
[string] $Assignee
[datetime] $StartDate
[datetime] $EndDate
[datetime] $DueDate
static [hashtable[]] $MemberDefinitions = @(
@{
MemberName = 'Duration'
MemberType = 'ScriptProperty'
Value = {
[datetime]$UnsetDate = 0
$StartNotSet = $this.StartDate -eq $UnsetDate
$EndNotSet = $this.EndDate -eq $UnsetDate
$StartAfterEnd = $this.StartDate -gt $this.EndDate
if ($StartNotSet -or $EndNotSet -or $StartAfterEnd) {
return $null
}
return $this.EndDate - $this.StartDate
}
}
)
static ExampleProject7() {
$TypeName = [ExampleProject7].Name
foreach ($Definition in [ExampleProject7]::MemberDefinitions) {
Update-TypeData -TypeName $TypeName @Definition
}
}
ExampleProject7() {}
ExampleProject7([string]$Name) {
$this.Name = $Name
}
}
$Project = [ExampleProject7]::new()
$Project
$null -eq $Project.Duration
Duration :
Name :
Size : 0
Completed : False
Assignee :
StartDate : 1/1/0001 12:00:00 AM
EndDate : 1/1/0001 12:00:00 AM
DueDate : 1/1/0001 12:00:00 AM
True
Standardvyn för en instans av klassen ExampleProject7 innehåller varaktigheten. Eftersom egenskaperna StartDate och EndDate inte har angetts är $nullegenskapen Varaktighet .
$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
När egenskaperna har angetts korrekt returnerar egenskapen Duration ett tidsintervall som representerar hur länge projektet kördes.
Standardegenskapsvärden
Varje klassegenskap har ett implicit standardvärde beroende på typen av egenskap.
Om en egenskap är en referenstyp, till exempel en sträng eller ett objekt, är $nulldet implicita standardvärdet . Om en egenskap är en värdetyp, till exempel ett tal, booleskt värde eller uppräkning, har egenskapen ett standardvärde beroende på typen:
- Numeriska typer, till exempel heltal och flyttalsnummer, som standard
0 - Booleska värden är standardvärdet
$false - Uppräkningar som standard är
0, inte ens uppräkningen definierar en etikett för0.
Mer information om standardvärden i .NET finns i Standardvärden för C#-typer (C#-referens).
Om du vill definiera ett explicit standardvärde för en egenskap deklarerar du egenskapen med en tilldelning till standardvärdet.
Den här definitionen för klassen ProjectTask definierar till exempel ett explicit standardvärde för guid-egenskapen och tilldelar ett slumpmässigt GUID till varje ny instans.
class ProjectTask {
[string] $Name
[string] $Description
[string] $Guid = (New-Guid).Guid
}
[ProjectTask]::new()
Name Description Guid
---- ----------- ----
aa96350c-358d-465c-96d1-a49949219eec
Dolda och statiska egenskaper kan också ha standardvärden.
Dolda egenskaper
Du kan dölja egenskaper för en klass genom att deklarera dem med nyckelordet hidden .
Dolda klassegenskaper är:
- Ingår inte i standardutdata för klassen.
- Ingår inte i listan över klassmedlemmar som returneras av cmdleten
Get-Member. Om du vill visa dolda egenskaper medGet-Memberanvänder du parametern Force . - Visas inte i tabbslut eller IntelliSense om inte slutförandet sker i klassen som definierar den dolda egenskapen.
- Offentliga medlemmar i klassen. De kan nås och ändras. Att dölja en egenskap gör den inte privat. Den döljer bara egenskapen enligt beskrivningen i föregående punkter.
Mer information om nyckelordet finns i hiddenabout_Hidden.
Statiska egenskaper
Du kan definiera en egenskap som tillhör själva klassen i stället för instanser av klassen genom att deklarera egenskapen med nyckelordet static . Egenskaper för statisk klass:
- Är alltid tillgängliga, oberoende av klass-instansiering.
- Delas mellan alla instanser av klassen.
- Är alltid tillgängliga.
- Kan ändras. Statiska egenskaper kan uppdateras. De är inte oföränderliga som standard.
- Live för hela sessionsintervallet.
Viktigt
Statiska egenskaper för klasser som definierats i PowerShell är inte oföränderliga. De kan
Egenskaper för härledd klass
När en klass härleds från en basklass ärver den basklassens egenskaper. Alla egenskaper som definierats i basklassen, inklusive dolda egenskaper, är tillgängliga för den härledda klassen.
En härledd klass kan åsidosätta en ärvd egenskap genom att omdefiniera den i klassdefinitionen. Egenskapen för den härledda klassen använder den omdefinierade typen och standardvärdet, om sådana finns. Om den ärvda egenskapen definierade ett standardvärde och den omdefinierade egenskapen inte gör det, har den ärvda egenskapen inget standardvärde.
Om en härledd klass inte åsidosätter en statisk egenskap kommer åtkomst till den statiska egenskapen via den härledda klassen åtkomst till basklassens statiska egenskap. Om du ändrar egenskapsvärdet via den härledda klassen ändras värdet för basklassen. Alla andra härledda klasser som inte åsidosätter den statiska egenskapen använder också värdet för egenskapen i basklassen. Att uppdatera värdet för en ärvd statisk egenskap i en klass som inte åsidosätter egenskapen kan ha oavsiktliga effekter för klasser som härleds från samma basklass.
I följande exempel visas beteendet för statiska egenskaper och instansegenskaper för härledda klasser.
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 för DerivedClassC är en tom sträng eftersom klassen omdefinierade egenskapen utan att ange ett standardvärde. För DerivedClassD beror Override värdet på att klassen omdefinierade egenskapen med strängen som standardvärde.
"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
Förutom DerivedClassD är värdet för den statiska egenskapen för de härledda klasserna detsamma som basklassen, eftersom de inte omdefinierar egenskapen. Detta gäller även för DerivedClassC, som ärver från DerivedClassB i stället för direkt från 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
När StaticProperty används och ändras via DerivedClassA påverkar det ändrade värdet varje klass förutom DerivedClassD.
Mer information om klassarv, inklusive ett omfattande exempel, finns i about_Classes_Inheritance.
Använda egenskapsattribut
PowerShell innehåller flera attributklasser som du kan använda för att förbättra datatypsinformationen och verifiera de data som tilldelats en egenskap. Med valideringsattribut kan du testa att värden som ges till egenskaper uppfyller definierade krav. Valideringen utlöses när värdet tilldelas.
Mer information om tillgängliga attribut finns i about_Functions_Advanced_Parameters.
Definiera instansegenskaper med Update-TypeData
Förutom att deklarera egenskaper direkt i klassdefinitionen kan du definiera egenskaper för instanser av en klass i den statiska konstruktorn med hjälp av cmdleten Update-TypeData .
Använd det här kodfragmentet som utgångspunkt för mönstret. Ersätt platshållartexten i vinkelparenteser efter behov.
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
}
}
}
Tips
Cmdleten Add-Member kan lägga till egenskaper och metoder i en klass i icke-statiska konstruktorer, men cmdleten körs varje gång konstruktorn anropas. Om du använder Update-TypeData den statiska konstruktorn ser du till att koden för att lägga till medlemmarna i klassen bara behöver köras en gång i en session.
Lägg bara till egenskaper i klassen i icke-statiska konstruktorer när de inte kan definieras med Update-TypeData, som skrivskyddade egenskaper.
Definiera aliasegenskaper
Aliasattributet har ingen effekt när det används i en klassegenskapsdeklaration. PowerShell använder bara det attributet för att definiera alias för cmdlet, parameter och funktionsnamn.
Om du vill definiera ett alias för en klassegenskap använder du Update-TypeData med AliasPropertyMemberType.
Den här definitionen av klassen OperablePair definierar till exempel två heltalsegenskaper x och y med aliasen LeftHandSide respektive 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 }
}
När aliasen har definierats kan användarna komma åt egenskaperna med något av namnen.
$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
Definiera beräknade egenskaper
Om du vill definiera en egenskap som refererar till värdena för andra egenskaper använder du cmdleten Update-TypeDataScriptProperty med MemberType.
Den här definitionen av klassen Budget definierar till exempel egenskaperna Utgifter och intäkter som matriser med flyttalsnummer. Den använder cmdleten Update-TypeData för att definiera beräknade egenskaper för totala utgifter, totala intäkter och nettointäkter.
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}
Definiera egenskaper med anpassad hämta och ange logik
PowerShell-klassegenskaper kan inte definiera anpassad getter- och setterlogik direkt. Du kan approximera den här funktionen genom att definiera en bakgrundsegenskap med nyckelordet hidden och använda Update-TypeData för att definiera en synlig egenskap med anpassad logik för att hämta och ange värdet.
Enligt konventionen definierar du namnet på den dolda bakgrundsegenskapen med ett understrecksprefix och använder kamelhölje. I stället för TaskCountnamnger du till exempel egenskapen _taskCounthidden backing .
I det här exemplet definierar klassen ProjectSize en dold heltalsegenskap med namnet _value. Den definierar Värde som en ScriptProperty med anpassad logik för att hämta och ange egenskapen _value . Seter scriptblock hanterar konvertering av strängrepresentationen av projektet till rätt storlek.
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
}
}
Med den anpassade gettern och settern definierad kan du ange egenskapen Value som antingen ett heltal eller en sträng.
$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
Begränsningar
PowerShell-klassegenskaper har följande begränsningar:
Statiska egenskaper är alltid föränderliga. PowerShell-klasser kan inte definiera oföränderliga statiska egenskaper.
Lösning: Ingen.
Egenskaper kan inte använda attributet ValidateScript eftersom attributargument för klassegenskap måste vara konstanter.
Lösning: Definiera en klass som ärver från typen ValidateArgumentsAttribute och använd det attributet i stället.
Direkt deklarerade egenskaper kan inte definiera anpassade implementeringar av getter och setter.
Lösning: Definiera en dold egenskap och använd
Update-TypeDataför att definiera den synliga getter- och setterlogik.Egenskaper kan inte använda aliasattributet. Attributet gäller endast för parametrar, cmdletar och funktioner.
Lösning: Använd cmdleten
Update-TypeDataför att definiera alias i klasskonstruktorerna.När en PowerShell-klass konverteras till JSON med cmdleten
ConvertTo-Jsoninnehåller utdata-JSON alla dolda egenskaper och deras värden.Lösning: Inga