Observação
O acesso a essa página exige autorização. Você pode tentar entrar ou alterar diretórios.
O acesso a essa página exige autorização. Você pode tentar alterar os diretórios.
Descrição curta
Descreve como você pode usar classes para criar seus próprios tipos personalizados.
Descrição longa
A partir da versão 5.0, o PowerShell tem uma sintaxe formal para definir classes e outros tipos definidos pelo usuário. A adição de classes permite que desenvolvedores e profissionais de TI adotem o PowerShell para uma gama mais ampla de casos de uso.
Uma declaração de classe é um blueprint usado para criar instâncias de objetos em tempo de execução. Quando você define uma classe, o nome da classe é o nome do tipo. Por exemplo, se você declarar uma classe chamada Device e inicializar uma variável $dev para uma nova instância do Device, $dev será um objeto ou uma instância do tipo Device. Cada instância do dispositivo pode ter valores diferentes em suas propriedades.
Cenários com suporte
- Defina tipos personalizados no PowerShell usando semântica de programação orientada a objeto, como classes, propriedades, métodos, herança etc.
- Defina recursos DSC e seus tipos associados usando a linguagem do PowerShell.
- Defina atributos personalizados para decorar variáveis, parâmetros e definições de tipo personalizado.
- Defina exceções personalizadas que podem ser capturadas pelo nome de tipo.
Sintaxe
Sintaxe de definição
As definições de classe usam a seguinte sintaxe:
class <class-name> [: [<base-class>][,<interface-list>]] {
[[<attribute>] [hidden] [static] <property-definition> ...]
[<class-name>([<constructor-argument-list>])
{<constructor-statement-list>} ...]
[[<attribute>] [hidden] [static] <method-definition> ...]
}
Sintaxe de instanciação
Para criar uma instância de uma classe, use uma das seguintes sintaxes:
[$<variable-name> =] New-Object -TypeName <class-name> [
[-ArgumentList] <constructor-argument-list>]
[$<variable-name> =] [<class-name>]::new([<constructor-argument-list>])
[$<variable-name> =] [<class-name>]<convertable-value-type>
Nota
Ao usar a sintaxe [<class-name>]::new(), os colchetes ao redor do nome da classe são obrigatórios. Os colchetes sinalizam uma definição de tipo para o PowerShell.
A <convertable-value-type> sintaxe funciona apenas para classes que têm um construtor padrão que não espera parâmetros. Ele cria uma instância da classe com o construtor padrão e, em seguida, usa a conversão de tipo de runtime para atribuir os valores fornecidos.
Exemplos
Exemplo 1 – Definição mínima
Este exemplo mostra a sintaxe mínima necessária para criar uma classe utilizável.
class Device {
[string]$Brand
}
$dev = [Device]::new()
$dev.Brand = "Fabrikam, Inc."
$dev
Brand
-----
Fabrikam, Inc.
Exemplo 2 – Usando a sintaxe de instanciação
Este exemplo define uma classe Book com várias propriedades, mas nenhum construtor.
class Book {
# Class properties
[string] $Title
[string] $Author
[string] $Synopsis
[string] $Publisher
[datetime] $PublishDate
[int] $PageCount
[string[]] $Tags
}
O exemplo a seguir mostra como o construtor padrão pode atribuir os valores de um valor compatível usando coerção de tipo. Neste exemplo, um hashtable é usado para fornecer os valores de propriedade.
$Book1 = [Book] @{
Title = '1984'
Author = 'George Orwell'
Synopsis = ''
Publisher = 'Secker & Warburg'
PublishDate = '1949-06-08'
PageCount = 328
Tags = @('Dystopian', 'Political Fiction', 'Social Science Fiction')
}
$Book1
Title : 1984
Author : George Orwell
Synopsis :
Publisher : Secker & Warburg
PublishDate : 6/8/1949 12:00:00 AM
PageCount : 328
Tags : {Dystopian, Political Fiction, Social Science Fiction}
Os pares chave-valor do hashtable são atribuídos às propriedades da instância. Se qualquer chave no hashtable não for um nome de propriedade válido, a instanciação falhará.
Neste exemplo, uma matriz é usada para fornecer os valores para a lista genérica.
$List = [System.Collections.Generic.List[int]] @(42, 43)
$List
42
43
Exemplo 3 – Classe com membros da instância
Este exemplo define uma classe Book com várias propriedades, construtores e métodos. Cada membro definido é uma instância membro, não um membro estático. As propriedades e os métodos só podem ser acessados por meio de uma instância criada da classe.
class Book {
# Class properties
[string] $Title
[string] $Author
[string] $Synopsis
[string] $Publisher
[datetime] $PublishDate
[int] $PageCount
[string[]] $Tags
# Default constructor
Book() { $this.Init(@{}) }
# Convenience constructor from hashtable
Book([hashtable]$Properties) { $this.Init($Properties) }
# Common constructor for title and author
Book([string]$Title, [string]$Author) {
$this.Init(@{Title = $Title; Author = $Author })
}
# Shared initializer method
[void] Init([hashtable]$Properties) {
foreach ($Property in $Properties.Keys) {
$this.$Property = $Properties.$Property
}
}
# Method to calculate reading time as 2 minutes per page
[timespan] GetReadingTime() {
if ($this.PageCount -le 0) {
throw 'Unable to determine reading time from page count.'
}
$Minutes = $this.PageCount * 2
return [timespan]::new(0, $Minutes, 0)
}
# Method to calculate how long ago a book was published
[timespan] GetPublishedAge() {
if (
$null -eq $this.PublishDate -or
$this.PublishDate -eq [datetime]::MinValue
) { throw 'PublishDate not defined' }
return (Get-Date) - $this.PublishDate
}
# Method to return a string representation of the book
[string] ToString() {
return "$($this.Title) by $($this.Author) ($($this.PublishDate.Year))"
}
}
O snippet a seguir cria uma instância da classe e mostra como ela se comporta. Depois de criar uma instância da classe Book, o exemplo usa os métodos GetReadingTime() e GetPublishedAge() para escrever uma mensagem sobre o livro.
$Book = [Book]::new(@{
Title = 'The Hobbit'
Author = 'J.R.R. Tolkien'
Publisher = 'George Allen & Unwin'
PublishDate = '1937-09-21'
PageCount = 310
Tags = @('Fantasy', 'Adventure')
})
$Book
$Time = $Book.GetReadingTime()
$Time = @($Time.Hours, 'hours and', $Time.Minutes, 'minutes') -join ' '
$Age = [Math]::Floor($Book.GetPublishedAge().TotalDays / 365.25)
"It takes $Time to read $Book,`nwhich was published $Age years ago."
Title : The Hobbit
Author : J.R.R. Tolkien
Synopsis :
Publisher : George Allen & Unwin
PublishDate : 9/21/1937 12:00:00 AM
PageCount : 310
Tags : {Fantasy, Adventure}
It takes 10 hours and 20 minutes to read The Hobbit by J.R.R. Tolkien (1937),
which was published 86 years ago.
Exemplo 4 – Classe com membros estáticos
A classe BookList neste exemplo baseia-se na classe Book no exemplo anterior. Embora a classe BookList não possa ser marcada como estática em si, a implementação define apenas a propriedade estática Books e um conjunto de métodos estáticos para gerenciar essa propriedade.
class BookList {
# Static property to hold the list of books
static [System.Collections.Generic.List[Book]] $Books
# Static method to initialize the list of books. Called in the other
# static methods to avoid needing to explicit initialize the value.
static [void] Initialize() { [BookList]::Initialize($false) }
static [bool] Initialize([bool]$Force) {
if ([BookList]::Books.Count -gt 0 -and -not $Force) {
return $false
}
[BookList]::Books = [System.Collections.Generic.List[Book]]::new()
return $true
}
# Ensure a book is valid for the list.
static [void] Validate([book]$Book) {
$Prefix = @(
'Book validation failed: Book must be defined with the Title,'
'Author, and PublishDate properties, but'
) -join ' '
if ($null -eq $Book) { throw "$Prefix was null" }
if ([string]::IsNullOrEmpty($Book.Title)) {
throw "$Prefix Title wasn't defined"
}
if ([string]::IsNullOrEmpty($Book.Author)) {
throw "$Prefix Author wasn't defined"
}
if ([datetime]::MinValue -eq $Book.PublishDate) {
throw "$Prefix PublishDate wasn't defined"
}
}
# Static methods to manage the list of books.
# Add a book if it's not already in the list.
static [void] Add([Book]$Book) {
[BookList]::Initialize()
[BookList]::Validate($Book)
if ([BookList]::Books.Contains($Book)) {
throw "Book '$Book' already in list"
}
$FindPredicate = {
param([Book]$b)
$b.Title -eq $Book.Title -and
$b.Author -eq $Book.Author -and
$b.PublishDate -eq $Book.PublishDate
}.GetNewClosure()
if ([BookList]::Books.Find($FindPredicate)) {
throw "Book '$Book' already in list"
}
[BookList]::Books.Add($Book)
}
# Clear the list of books.
static [void] Clear() {
[BookList]::Initialize()
[BookList]::Books.Clear()
}
# Find a specific book using a filtering scriptblock.
static [Book] Find([scriptblock]$Predicate) {
[BookList]::Initialize()
return [BookList]::Books.Find($Predicate)
}
# Find every book matching the filtering scriptblock.
static [Book[]] FindAll([scriptblock]$Predicate) {
[BookList]::Initialize()
return [BookList]::Books.FindAll($Predicate)
}
# Remove a specific book.
static [void] Remove([Book]$Book) {
[BookList]::Initialize()
[BookList]::Books.Remove($Book)
}
# Remove a book by property value.
static [void] RemoveBy([string]$Property, [string]$Value) {
[BookList]::Initialize()
$Index = [BookList]::Books.FindIndex({
param($b)
$b.$Property -eq $Value
}.GetNewClosure())
if ($Index -ge 0) {
[BookList]::Books.RemoveAt($Index)
}
}
}
Agora que BookList está definido, o livro do exemplo anterior pode ser adicionado à lista.
$null -eq [BookList]::Books
[BookList]::Add($Book)
[BookList]::Books
True
Title : The Hobbit
Author : J.R.R. Tolkien
Synopsis :
Publisher : George Allen & Unwin
PublishDate : 9/21/1937 12:00:00 AM
PageCount : 310
Tags : {Fantasy, Adventure}
O snippet a seguir chama os métodos estáticos para a classe.
[BookList]::Add([Book]::new(@{
Title = 'The Fellowship of the Ring'
Author = 'J.R.R. Tolkien'
Publisher = 'George Allen & Unwin'
PublishDate = '1954-07-29'
PageCount = 423
Tags = @('Fantasy', 'Adventure')
}))
[BookList]::Find({
param ($b)
$b.PublishDate -gt '1950-01-01'
}).Title
[BookList]::FindAll({
param($b)
$b.Author -match 'Tolkien'
}).Title
[BookList]::Remove($Book)
[BookList]::Books.Title
[BookList]::RemoveBy('Author', 'J.R.R. Tolkien')
"Titles: $([BookList]::Books.Title)"
[BookList]::Add($Book)
[BookList]::Add($Book)
The Fellowship of the Ring
The Hobbit
The Fellowship of the Ring
The Fellowship of the Ring
Titles:
Exception:
Line |
84 | throw "Book '$Book' already in list"
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
| Book 'The Hobbit by J.R.R. Tolkien (1937)' already in list
Exemplo 5 – Definição de classe com e sem afinidade de runspace
O método ShowRunspaceId() de [UnsafeClass] relata IDs de thread diferentes, mas a mesma ID do runspace. Eventualmente, o estado da sessão é corrompido causando um erro, como Global scope cannot be removed.
# Class definition with Runspace affinity (default behavior)
class UnsafeClass {
static [Object] ShowRunspaceId($Val) {
return [pscustomobject]@{
ThreadId = [Threading.Thread]::CurrentThread.ManagedThreadId
RunspaceId = [runspace]::DefaultRunspace.Id
}
}
}
$unsafe = [UnsafeClass]::new()
while ($true) {
1..10 | ForEach-Object -Parallel {
Start-Sleep -ms 100
($Using:unsafe)::ShowRunspaceId($_)
}
}
Nota
Este exemplo é executado em um loop infinito. Insira Ctrl+C para interromper a execução.
O método ShowRunspaceId() de [SafeClass] relata diferentes IDs de thread e runspace.
# Class definition with NoRunspaceAffinity attribute
[NoRunspaceAffinity()]
class SafeClass {
static [Object] ShowRunspaceId($Val) {
return [pscustomobject]@{
ThreadId = [Threading.Thread]::CurrentThread.ManagedThreadId
RunspaceId = [runspace]::DefaultRunspace.Id
}
}
}
$safe = [SafeClass]::new()
while ($true) {
1..10 | ForEach-Object -Parallel {
Start-Sleep -ms 100
($Using:safe)::ShowRunspaceId($_)
}
}
Nota
Este exemplo é executado em um loop infinito. Insira Ctrl+C para interromper a execução.
Propriedades de classe
As propriedades são variáveis declaradas no escopo da classe. Uma propriedade pode ser de qualquer tipo interno ou de uma instância de outra classe. As classes podem ter zero ou mais propriedades. As classes não têm uma contagem máxima de propriedades.
Para obter mais informações, consulte about_Classes_Properties.
Métodos de classe
Os métodos definem as ações que uma classe pode executar. Os métodos podem adotar parâmetros que especificam dados de entrada. Os métodos sempre definem um tipo de saída. Se um método não retornar nenhuma saída, ele deverá ter o tipo de saída Void. Se um método não definir explicitamente um tipo de saída, o tipo de saída do método será Void.
Para obter mais informações, consulte about_Classes_Methods.
Construtores de classe
Os construtores permitem definir valores padrão e validar a lógica do objeto no momento da criação da instância da classe. Construtores têm o mesmo nome da classe. Os construtores podem ter parâmetros para inicializar os membros de dados do novo objeto.
Para obter mais informações, consulte about_Classes_Constructors.
Palavra-chave oculta
A palavra-chave hidden oculta um membro da classe. O membro ainda está acessível ao usuário e está disponível em todos os escopos nos quais o objeto está disponível.
Os membros ocultos estão ocultos do cmdlet Get-Member e não podem ser exibidos usando a conclusão da guia ou o IntelliSense fora da definição de classe.
A palavra-chave hidden só se aplica aos membros da classe, não a uma classe em si.
Membros de classe ocultos são:
- Não incluído na saída padrão da classe.
- Não incluído na lista de membros de classe retornados pelo cmdlet
Get-Member. Para mostrar membros ocultos comGet-Member, use o parâmetro Force. - Não exibido na conclusão da guia ou no IntelliSense, a menos que a conclusão ocorra na classe que define o membro oculto.
- Membros públicos da classe. Eles podem ser acessados, herdados e modificados. Ocultar um membro não o torna privado. Ele oculta apenas o membro conforme descrito nos pontos anteriores.
Nota
Quando você oculta qualquer sobrecarga para um método, esse método é removido do IntelliSense, os resultados de conclusão e a saída padrão para Get-Member.
Quando você oculta qualquer construtor, a opção new() é removida do IntelliSense e os resultados de conclusão.
Para obter mais informações sobre a palavra-chave, consulte about_Hidden. Para obter mais informações sobre propriedades ocultas, consulte about_Classes_Properties. Para obter mais informações sobre métodos ocultos, consulte about_Classes_Methods. Para obter mais informações sobre construtores ocultos, consulte about_Classes_Constructors.
Palavra-chave estática
A palavra-chave static define uma propriedade ou um método que existe na classe e não precisa de nenhuma instância.
Uma propriedade estática está sempre disponível, independente da instanciação de classe. Uma propriedade estática é compartilhada em todas as instâncias da classe. Um método estático está sempre disponível. Todas as propriedades estáticas são dinâmicas para todo o intervalo de sessão.
A palavra-chave static só se aplica aos membros da classe, não a uma classe em si.
Para obter mais informações sobre propriedades estáticas, consulte about_Classes_Properties. Para obter mais informações sobre métodos estáticos, consulte about_Classes_Methods. Para obter mais informações sobre construtores estáticos, consulte about_Classes_Constructors.
Herança em classes do PowerShell
Você pode estender uma classe criando uma nova classe que deriva de uma classe existente. A classe derivada herda as propriedades e os métodos da classe base. Você pode adicionar ou substituir os membros da classe base conforme necessário.
O PowerShell não dá suporte a várias heranças. As classes não podem herdar diretamente de mais de uma classe.
As classes também podem herdar de interfaces, que definem um contrato. Uma classe que herda de uma interface deve implementar esse contrato. Quando isso acontece, a classe pode ser usada como qualquer outra classe implementando essa interface.
Para obter mais informações sobre como derivar classes que herdam de uma classe base ou implementar interfaces, consulte about_Classes_Inheritance.
Atributo NoRunspaceAffinity
Um runspace é o ambiente operacional para os comandos invocados pelo PowerShell. Esse ambiente inclui os comandos e os dados que estão atualmente presentes e quaisquer restrições de idioma que se aplicam atualmente.
Por padrão, uma classe do PowerShell é afiliada ao Runspace em que ele é criado. O uso de uma classe do PowerShell em ForEach-Object -Parallel não é seguro.
As invocações de método na classe são colocadas novamente no runspace em que ela foi criada, o que pode corromper o estado do do runspace ou causar um deadlock.
Adicionar o atributo NoRunspaceAffinity à definição de classe garante que a classe do PowerShell não esteja afiliada a um runspace específico. Invocações de método, instância e estáticas, usam o de runspace do thread em execução e o estado da sessão atual do thread.
O atributo foi adicionado no PowerShell 7.4.
Para obter uma ilustração da diferença de comportamento para classes com e sem o atributo, consulte o NoRunspaceAffinityExemplo 5.
Exportar classes com aceleradores de tipo
Por padrão, os módulos do PowerShell não exportam automaticamente classes e enumerações definidas no PowerShell. Os tipos personalizados não estão disponíveis fora do módulo sem chamar uma instrução using module.
No entanto, se um módulo adicionar aceleradores de tipo, esses aceleradores de tipo estarão imediatamente disponíveis na sessão após os usuários importarem o módulo.
Nota
Adicionar aceleradores de tipo à sessão usa uma API interna (não pública). Usar essa API pode causar conflitos. O padrão descrito abaixo gerará um erro se um acelerador de tipo com o mesmo nome já existir quando você importar o módulo. Ele também remove os aceleradores de tipo quando você remove o módulo da sessão.
Esse padrão garante que os tipos estejam disponíveis em uma sessão. Ele não afeta o IntelliSense nem a conclusão ao criar um arquivo de script no VS Code.
Para obter o IntelliSense e sugestões de conclusão para tipos personalizados no VS Code, você precisa adicionar uma instrução using module à parte superior do script.
O padrão a seguir mostra como você pode registrar classes e enumerações do PowerShell como aceleradores de tipo em um módulo. Adicione o snippet ao módulo de script raiz após qualquer definição de tipo. Verifique se a variável $ExportableTypes contém cada um dos tipos que você deseja disponibilizar aos usuários ao importar o módulo. O outro código não requer edição.
# Define the types to export with type accelerators.
$ExportableTypes =@(
[DefinedTypeName]
)
# Get the internal TypeAccelerators class to use its static methods.
$TypeAcceleratorsClass = [psobject].Assembly.GetType(
'System.Management.Automation.TypeAccelerators'
)
# Ensure none of the types would clobber an existing type accelerator.
# If a type accelerator with the same name exists, throw an exception.
$ExistingTypeAccelerators = $TypeAcceleratorsClass::Get
foreach ($Type in $ExportableTypes) {
if ($Type.FullName -in $ExistingTypeAccelerators.Keys) {
$Message = @(
"Unable to register type accelerator '$($Type.FullName)'"
'Accelerator already exists.'
) -join ' - '
throw [System.Management.Automation.ErrorRecord]::new(
[System.InvalidOperationException]::new($Message),
'TypeAcceleratorAlreadyExists',
[System.Management.Automation.ErrorCategory]::InvalidOperation,
$Type.FullName
)
}
}
# Add type accelerators for every exportable type.
foreach ($Type in $ExportableTypes) {
$TypeAcceleratorsClass::Add($Type.FullName, $Type)
}
# Remove type accelerators when the module is removed.
$MyInvocation.MyCommand.ScriptBlock.Module.OnRemove = {
foreach($Type in $ExportableTypes) {
$TypeAcceleratorsClass::Remove($Type.FullName)
}
}.GetNewClosure()
Quando os usuários importam o módulo, todos os tipos adicionados aos aceleradores de tipo para a sessão ficam imediatamente disponíveis para IntelliSense e conclusão. Quando o módulo é removido, os aceleradores de tipo também são.
Importar classes manualmente de um módulo do PowerShell
Import-Module e a instrução #Requires importam apenas as funções, os aliases e as variáveis do módulo, conforme definido pelo módulo. As classes não são importadas.
Se um módulo definir classes e enumerações, mas não adicionar aceleradores de tipo para esses tipos, use uma instrução using module para importá-las.
A instrução using module importa classes e enumerações do módulo raiz (ModuleToProcess) de um módulo de script ou módulo binário. Ele não importa consistentemente classes definidas em módulos aninhados ou classes definidas em scripts que são de origem de ponto no módulo raiz. Defina classes que você deseja estar disponível para usuários fora do módulo diretamente no módulo raiz.
Para obter mais informações sobre a instrução using, consulte about_Using.
Carregar código recentemente alterado durante o desenvolvimento
Durante o desenvolvimento de um módulo de script, é comum fazer alterações no código e carregar a nova versão do módulo usando Import-Module com o parâmetro Force. Recarregar o módulo só funciona para alterações em funções no módulo raiz.
Import-Module não recarrega nenhum módulo aninhado. Além disso, não há como carregar classes atualizadas.
Para garantir que você esteja executando a versão mais recente, inicie uma nova sessão.
Classes e enumerações definidas no PowerShell e importadas com uma instrução using não podem ser descarregadas.
Outra prática de desenvolvimento comum é separar o código em arquivos diferentes. Se você tiver uma função em um arquivo que use classes definidas em outro módulo, use a instrução using module para garantir que as funções tenham as definições de classe necessárias.
Não há suporte para o tipo PSReference com membros da classe
O acelerador de tipo [ref] é abreviação da classe PSReference. O uso de [ref] para converter um membro de classe falha silenciosamente. APIs que usam parâmetros [ref] não podem ser usadas com membros da classe. A classe PSReference foi projetada para dar suporte a objetos COM. Objetos COM têm casos em que você precisa passar um valor por referência.
Para obter mais informações, consulte classe PSReference.
Limitações
As listas a seguir incluem limitações para definir classes do PowerShell e solução alternativa para essas limitações, se houver.
Limitações gerais
Os membros da classe não podem usar PSReference como seu tipo.
Solução alternativa: nenhuma.
As classes do PowerShell não podem ser descarregadas ou recarregadas em uma sessão.
Solução alternativa: inicie uma nova sessão.
As classes do PowerShell definidas em um módulo não são importadas automaticamente.
Solução alternativa: adicione os tipos definidos à lista de aceleradores de tipo no módulo raiz. Isso disponibiliza os tipos na importação do módulo.
As palavras-chave
hiddenestaticse aplicam apenas aos membros da classe, não a uma definição de classe.Solução alternativa: nenhuma.
Por padrão, as classes do PowerShell não são seguras de usar na execução paralela entre runspaces. Quando você invoca métodos em uma classe, o PowerShell retorna as invocações para o Runspace em que a classe foi criada, o que pode corromper o estado do do runspace ou causar um deadlock.
Solução alternativa: adicione o atributo
NoRunspaceAffinityà declaração de classe.
Limitações do construtor
O encadeamento do construtor não é implementado.
Solução alternativa: defina métodos
Init()ocultos e chame-os de dentro dos construtores.Os parâmetros do construtor não podem usar nenhum atributo, incluindo atributos de validação.
Solução alternativa: reatribua os parâmetros no corpo do construtor com o atributo de validação.
Os parâmetros do construtor não podem definir valores padrão. Os parâmetros são sempre obrigatórios.
Solução alternativa: nenhuma.
Se qualquer sobrecarga de um construtor estiver oculta, todas as sobrecargas do construtor também serão tratadas como ocultas.
Solução alternativa: nenhuma.
Limitações de método
Os parâmetros de método não podem usar nenhum atributo, incluindo atributos de validação.
Solução alternativa: reatribua os parâmetros no corpo do método com o atributo de validação ou defina o método no construtor estático com o cmdlet
Update-TypeData.Parâmetros de método não podem definir valores padrão. Os parâmetros são sempre obrigatórios.
Solução alternativa: defina o método no construtor estático com o cmdlet
Update-TypeData.Os métodos são sempre públicos, mesmo quando estão ocultos. Eles podem ser substituídos quando a classe é herdada.
Solução alternativa: nenhuma.
Se qualquer sobrecarga de um método estiver oculta, cada sobrecarga desse método também será tratada como oculta.
Solução alternativa: nenhuma.
Limitações de propriedade
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: nenhuma.
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 de getter e setter visíveis.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 cmdlet
Update-TypeDatapara definir aliases nos construtores de classe.Quando uma classe do PowerShell é convertida em JSON com o cmdlet
ConvertTo-Json, o JSON de saída inclui todas as propriedades ocultas e seus valores.Solução alternativa: Nenhum
Limitações de herança
O PowerShell não dá suporte à definição de interfaces no código de script.
Solução alternativa: defina interfaces em C# e referencie o assembly que define as interfaces.
As classes do PowerShell só podem herdar de uma classe base.
Solução alternativa: a herança de classe é transitiva. Uma classe derivada pode herdar de outra classe derivada para obter as propriedades e os métodos de uma classe base.
Ao herdar de uma classe ou interface genérica, o parâmetro de tipo para o genérico já deve ser definido. Uma classe não pode se definir como o parâmetro de tipo para uma classe ou interface.
Solução alternativa: para derivar de uma classe base ou interface genérica, defina o tipo personalizado em um arquivo de
.psm1diferente e use a instruçãousing modulepara carregar o tipo. Não há solução alternativa para um tipo personalizado usar-se como o parâmetro de tipo ao herdar de um genérico.
Consulte também
Colaborar conosco no GitHub
A fonte deste conteúdo pode ser encontrada no GitHub, onde você também pode criar e revisar problemas e solicitações de pull. Para obter mais informações, confira o nosso guia para colaboradores.
