about_Classes_Properties
Descrição breve
Descreve como definir propriedades para classes do PowerShell.
Descrição longa
As propriedades são membros da classe que contêm dados. As propriedades são declaradas como variáveis no escopo da classe. Uma propriedade pode ser de qualquer tipo interno ou uma instância de outra classe. As classes podem zerar ou mais propriedades. As classes não têm uma contagem máxima de propriedades.
As propriedades de classe podem ter qualquer número de atributos, incluindo os atributos ocultos e estáticos . Cada definição de propriedade deve incluir um tipo para a propriedade. Você pode definir um valor padrão para uma propriedade.
Sintaxe
As propriedades de classe usam as seguintes sintaxes:
Sintaxe unifilar
[[<attribute>]...] [<property-type>] $<property-name> [= <default-value>]
Sintaxe multilinha
[[<attribute>]...]
[<property-type>]
$<property-name> [= <default-value>]
Exemplos
Exemplo 1 – Propriedades mínimas de classe
As propriedades da classe ExampleProject1 usam tipos internos sem atributos ou valores padrão.
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
O valor padrão para as propriedades Name e Assignee é $null porque elas são digitadas como cadeias de caracteres, que é um tipo de referência. As outras propriedades têm o valor padrão para o tipo definido, pois são propriedades do tipo valor. Para obter mais informações sobre os valores padrão para propriedades, consulte Valores de propriedade padrão.
Exemplo 2 – Propriedades de classe com tipos personalizados
As propriedades de ExampleProject2 incluem uma enumeração personalizada e uma classe definida no PowerShell antes da classe 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
Exemplo 3 – Propriedade de classe com um atributo de validação
A classe ExampleProject3 define a propriedade Size como um inteiro que deve ser maior ou igual a 0 e menor ou igual a 16. Ele usa o atributo ValidateRange para limitar o valor.
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
Quando ExampleProject3 é instanciado, o tamanho padrão é 0. Definir a propriedade como um valor dentro do intervalo válido atualiza o valor.
$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
Quando Size é definido como um valor inválido fora do intervalo, o PowerShell gera uma exceção e o valor não é alterado.
$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
Exemplo 4 - Propriedade de classe com um valor padrão explícito
A classe ExampleProject4 padroniza o valor da propriedade StartDate para a data atual.
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
Exemplo 5 - Propriedade de classe oculta
A propriedade Guid da classe ExampleProject5 tem a hidden palavra-chave. A propriedade Guid não é mostrada na saída padrão da classe ou na lista de propriedades retornadas por 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;}
Exemplo 6 - Propriedade de classe estática
A classe ExampleProject6 define a propriedade estática Projects como uma lista de todos os projetos criados. O construtor padrão da classe adiciona a nova instância à lista de projetos.
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
Exemplo 7 - Definindo uma propriedade no construtor
A classe ExampleProject7 define a propriedade de script Duration no construtor de classe estática com o Update-TypeData cmdlet. Usar o Update-TypeData cmdlet ou Add-Member é a única maneira de definir propriedades avançadas para classes do PowerShell.
A propriedade Duration retorna um valor de $null , a menos que as propriedades StartDate e EndDate estejam definidas e StartDate seja definido como anterior a 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
A exibição padrão de uma instância da classe ExampleProject7 inclui a duração. Como as propriedades StartDate e EndDate não estão definidas, a propriedade Duration é $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
Com as propriedades definidas corretamente, a propriedade Duration retorna um período de tempo que representa por quanto tempo o projeto foi executado.
Valores de propriedade padrão
Cada propriedade de classe tem um valor padrão implícito, dependendo do tipo da propriedade.
Se uma propriedade for um tipo de referência, como uma cadeia de caracteres ou um objeto, o valor padrão implícito será $null. Se uma propriedade for um tipo de valor, como um número, booleano ou enumeração, a propriedade terá um valor padrão, dependendo do tipo:
- Tipos numéricos, como inteiros e números de ponto flutuante, são padronizados como
0 - Os valores booleanos são padronizados para
$false - As enumerações são padronizadas para
0, mesmo que a enumeração não defina um rótulo para0.
Para obter mais informações sobre valores padrão no .NET, consulte Valores padrão de tipos C# (referência de C#).
Para definir um valor padrão explícito para uma propriedade, declare a propriedade com uma atribuição ao valor padrão.
Por exemplo, essa definição para a classe ProjectTask define um valor padrão explícito para a propriedade Guid , atribuindo um GUID aleatório a cada nova instância.
class ProjectTask {
[string] $Name
[string] $Description
[string] $Guid = (New-Guid).Guid
}
[ProjectTask]::new()
Name Description Guid
---- ----------- ----
aa96350c-358d-465c-96d1-a49949219eec
Propriedades ocultas e estáticas também podem ter valores padrão.
Propriedades ocultas
Você pode ocultar propriedades de uma classe declarando-as com a hidden palavra-chave.
As propriedades de classe ocultas são:
- Não incluído na saída padrão da classe.
- Não incluído na lista de membros da classe retornados pelo
Get-Membercmdlet. Para mostrar propriedades ocultas comGet-Member, use o parâmetro Force . - Não é exibido na conclusão de tabulação ou no IntelliSense, a menos que a conclusão ocorra na classe que define a propriedade oculta.
- Membros públicos da classe. Eles podem ser acessados e modificados. Ocultar uma propriedade não a torna privada. Ele apenas oculta a propriedade conforme descrito nos pontos anteriores.
Para obter mais informações sobre a palavra-chave, consulte about_Hiddenhidden.
Propriedades estáticas
Você pode definir uma propriedade como pertencente à própria classe em vez de instâncias da classe, declarando a propriedade com a static palavra-chave. Propriedades da classe estática:
- Estão sempre disponíveis, independentemente da instanciação de classe.
- São compartilhados em todas as instâncias da classe.
- Estão sempre disponíveis.
- São modificáveis. As propriedades estáticas podem ser atualizadas. Eles não são imutáveis por padrão.
- Ao vivo durante toda a sessão.
Importante
As propriedades estáticas para classes definidas no PowerShell não são imutáveis. Eles podem
Propriedades de classe derivadas
Quando uma classe deriva de uma classe base, ela herda as propriedades da classe base. Todas as propriedades definidas na classe base, incluindo propriedades ocultas, estão disponíveis na classe derivada.
Uma classe derivada pode substituir uma propriedade herdada redefinindo-a na definição de classe. A propriedade na classe derivada usa o tipo redefinido e o valor padrão, se houver. Se a propriedade herdada tiver definido um valor padrão e a propriedade redefinida não, a propriedade herdada não terá nenhum valor padrão.
Se uma classe derivada não substituir uma propriedade estática, acessar a propriedade estática por meio da classe derivada acessará a propriedade estática da classe base. Modificar o valor da propriedade por meio da classe derivada modifica o valor na classe base. Qualquer outra classe derivada que não substitua a propriedade estática também usa o valor da propriedade na classe base. Atualizar o valor de uma propriedade estática herdada em uma classe que não substitui a propriedade pode ter efeitos não intencionais para classes derivadas da mesma classe base.
O exemplo a seguir mostra o comportamento de propriedades estáticas e de instância em classes derivadas.
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
A InstanceProperty para DerivedClassC é uma cadeia de caracteres vazia porque a classe redefiniu a propriedade sem definir um valor padrão. Para DerivedClassD , o valor é Override porque a classe redefiniu a propriedade com essa cadeia de caracteres como o valor padrão.
"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
Exceto para DerivedClassD, o valor da propriedade estática para as classes derivadas é o mesmo que a classe base, pois elas não redefinem a propriedade. Isso se aplica até mesmo a DerivedClassC, que herda de DerivedClassB em vez de diretamente de 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
Quando StaticProperty é acessado e modificado por meio de DerivedClassA, o valor alterado afeta todas as classes, exceto DerivedClassD.
Para obter mais informações sobre herança de classe, incluindo um exemplo abrangente, consulte about_Classes_Inheritance.
Usando atributos de propriedade
O PowerShell inclui várias classes de atributo que você pode usar para aprimorar as informações de tipo de dados e validar os dados atribuídos a uma propriedade. Os atributos de validação permitem que você teste se os valores fornecidos às propriedades atendem aos requisitos definidos. A validação é acionada no momento em que o valor é atribuído.
Para obter mais informações sobre os atributos disponíveis, consulte about_Functions_Advanced_Parameters.
Definindo propriedades de instância com Update-TypeData
Além de declarar propriedades diretamente na definição de classe, você pode definir propriedades para instâncias de uma classe no construtor estático usando o Update-TypeData cmdlet.
Use esse snippet como ponto de partida para o padrão. Substitua o texto do espaço reservado entre colchetes angulares, conforme necessário.
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
}
}
}
Dica
O Add-Member cmdlet pode adicionar propriedades e métodos a uma classe em construtores não estáticos, mas o cmdlet é executado sempre que o construtor é chamado. O uso Update-TypeData do construtor estático garante que o código para adicionar os membros à classe só precise ser executado uma vez em uma sessão.
Adicione propriedades à classe apenas em construtores não estáticos quando elas não puderem ser definidas com Update-TypeData, como propriedades somente leitura.
Definindo propriedades de alias
O atributo Alias não tem efeito quando usado em uma declaração de propriedade de classe. O PowerShell usa apenas esse atributo para definir aliases para nomes de cmdlet, parâmetro e função.
Para definir um alias para uma propriedade de classe, use Update-TypeData com o AliasProperty MemberType.
Por exemplo, essa definição da classe OperablePair define duas propriedades inteiras x e y com os aliases LeftHandSide e RightHandSide , respectivamente.
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 }
}
Com os aliases definidos, os usuários podem acessar as propriedades com qualquer um dos nomes.
$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
Definindo propriedades calculadas
Para definir uma propriedade que faça referência aos valores de outras propriedades, use o Update-TypeData cmdlet com o ScriptProperty MemberType.
Por exemplo, essa definição da classe Budget define as propriedades Expenses e Revenues como matrizes de números de ponto flutuante. Ele usa o Update-TypeData cmdlet para definir propriedades calculadas para despesas totais, receitas totais e receita líquida.
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}
Definindo propriedades com lógica personalizada de obtenção e definição
As propriedades de classe do PowerShell não podem definir a lógica personalizada do getter e do setter diretamente. Você pode aproximar essa funcionalidade definindo uma propriedade de suporte com a hidden palavra-chave e usando Update-TypeData para definir uma propriedade visível com lógica personalizada para obter e definir o valor.
Por convenção, defina o nome da propriedade de suporte oculto com um prefixo de sublinhado e use maiúsculas e minúsculas concatenadas. Por exemplo, em vez de TaskCount, nomeie a propriedade _taskCountde suporte oculto .
Neste exemplo, a classe ProjectSize define uma propriedade inteira oculta chamada _value. Ele define Value como uma ScriptProperty lógica personalizada para obter e definir a propriedade _value . O scriptblock setter manipula a conversão da representação de cadeia de caracteres do projeto para o tamanho correto.
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
}
}
Com o getter e o setter personalizados definidos, você pode definir a propriedade Value como um inteiro ou uma cadeia de caracteres.
$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
Limitações
As propriedades de classe do PowerShell têm as seguintes limitações:
As propriedades estáticas são sempre mutáveis. As classes do PowerShell não podem definir propriedades estáticas imutáveis.
Solução alternativa: Não há.
As propriedades não podem usar o atributo ValidateScript, pois os argumentos de atributo de propriedade de classe devem ser constantes.
Solução alternativa: defina uma classe que herda do tipo ValidateArgumentsAttribute e use esse atributo.
As propriedades declaradas diretamente não podem definir implementações personalizadas de getter e setter.
Solução alternativa: Defina uma propriedade oculta e use
Update-TypeDatapara definir a lógica visível do getter e do setter.As propriedades não podem usar o atributo Alias . O atributo só se aplica a parâmetros, cmdlets e funções.
Solução alternativa: use o
Update-TypeDatacmdlet para definir aliases nos construtores de classe.Quando uma classe do PowerShell é convertida em JSON com o
ConvertTo-Jsoncmdlet, o JSON de saída inclui todas as propriedades ocultas e seus valores.Solução alternativa: Não há
