about_Classes_Properties
Breve descrição
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 zero 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 de uma linha
[[<attribute>]...] [<property-type>] $<property-name> [= <default-value>]
Sintaxe de várias linhas
[[<attribute>]...]
[<property-type>]
$<property-name> [= <default-value>]
Exemplos
Exemplo 1 - Propriedades de classe mínima
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 strings, que é um tipo de referência. As outras propriedades têm o valor padrão para seu tipo definido, porque são propriedades de tipo de 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 Class 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 Size assume como 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 Tamanho é 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 Class 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 aparece na saída padrão para a classe ou na lista de propriedades retornadas pelo 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 para a 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 do script Duration no construtor da 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 definida 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
O modo de exibição padrão para 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 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 vírgula flutuante, padrão para
0 - Valores booleanos padrão para
$false - Enumerações padrão para
0, mesmo a enumeração não define um rótulo para0.
Para obter mais informações sobre valores padrão no .NET, consulte Valores padrão de tipos C# (referência C#).
Para definir um valor padrão explícito para uma propriedade, declare a propriedade com uma atribuição para o 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
As 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 para a classe.
- Não incluído na lista de membros de classe retornados pelo
Get-Membercmdlet. Para mostrar propriedades ocultas comGet-Membero , use o parâmetro Force . - Não é exibido no preenchimento de tabulação ou no IntelliSense, a menos que a conclusão ocorra na classe que define a propriedade oculta.
- Membros públicos da turma. Eles podem ser acessados e modificados. Ocultar uma propriedade não a torna privada. Apenas oculta a propriedade conforme descrito nos pontos anteriores.
Para obter mais informações sobre a hidden palavra-chave, consulte about_Hidden.
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 da 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 duração da sessão.
Importante
As propriedades estáticas das classes definidas no PowerShell não são imutáveis. Podem
Propriedades de classe derivada
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 definiu um valor padrão e a propriedade redefinida não, a propriedade herdada não terá valor padrão.
Se uma classe derivada não substituir uma propriedade estática, o acesso à propriedade static por meio da classe derivada acessará a propriedade static 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 static 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 para 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
O 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 static para as classes derivadas é o mesmo que a classe base, porque 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 testar se os valores dados às propriedades atendem aos requisitos definidos. A validação é acionada no momento em que o valor é atribuído.
Para obter mais informações sobre 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 este trecho 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
}
}
}
Gorjeta
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. Usar Update-TypeData no construtor estático garante que o código para adicionar os membros à classe só precisa ser executado uma vez em uma sessão.
Adicione propriedades à classe somente 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
Definição de 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 Revenue como matrizes de números de vírgula flutuante. Ele usa o Update-TypeData cmdlet para definir propriedades calculadas para despesas totais, receitas totais e lucro líquido.
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 de obtenção e definição personalizada
As propriedades de classe do PowerShell não podem definir diretamente a lógica personalizada de getter e setter. Você pode aproximar essa funcionalidade definindo uma propriedade de suporte com a hidden palavra-chave e usando Update-TypeData para definir uma propriedade visible com lógica personalizada para obter e definir o valor.
Por convenção, defina o nome da propriedade de suporte oculta com um prefixo de sublinhado e use caixa de camelo. Por exemplo, em vez de TaskCount, nomeie a propriedade _taskCountde suporte oculta .
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 setter scriptblock lida com 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 setter personalizados definidos, você pode definir a propriedade Value como um inteiro ou 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.
Alternativa: nenhuma.
As propriedades não podem usar o atributo ValidateScript, porque os argumentos do atributo de propriedade de classe devem ser constantes.
Solução alternativa: defina uma classe que herda do tipo ValidateArgumentsAttribute e use esse atributo em vez disso.
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 getter e setter visível.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.Alternativa: nenhuma
