about_Classes
Descrição breve
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 de 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 os recursos de 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.
Syntax
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 instanciar 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>]@{[<class-property-hashtable>]}
Observação
Ao usar a [<class-name>]::new() sintaxe, os colchetes ao redor do nome da classe são obrigatórios. Os colchetes sinalizam uma definição de tipo para o PowerShell.
A sintaxe de tabela de hash 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 atribui os pares chave-valor às propriedades da instância. Se qualquer chave na tabela de hash não for um nome de propriedade válido, o PowerShell gerará um erro.
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 – Classe com membros de instância
Este exemplo define uma classe Book com várias propriedades, construtores e métodos. Cada membro definido é um membro de instância , 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 GetReadingTime() métodos 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 3 – Classe com membros estáticos
A classe BookList neste exemplo baseia-se na classe Book no exemplo 2. Embora a classe BookList não possa ser marcada como estática, 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 4 – Execução paralela corrompendo um runspace
O ShowRunspaceId() método de relata diferentes IDs de [UnsafeClass] thread, mas a mesma ID do runspace. Eventualmente, o estado da sessão está 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($_)
}
}
Observação
Este exemplo é executado em um loop infinito. Insira Ctrl+C para interromper a execução.
Propriedades da classe
As propriedades são variáveis declaradas no escopo da classe. Uma propriedade pode ser de qualquer tipo interno ou 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 utilizar 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 . Os construtores têm o mesmo nome que a 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 oculto
O hidden palavra-chave oculta um membro de 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 Get-Member cmdlet e não podem ser exibidos usando o preenchimento de tabulação ou o IntelliSense fora da definição de classe.
O hidden palavra-chave só se aplica a membros de classe, não a uma classe em si.
Os membros de classe ocultos 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 membros ocultos comGet-Member, use o parâmetro Force . - Não exibido no preenchimento com tabulação 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.
Observação
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 da conclusão.
Para obter mais informações sobre o 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 Static
O static palavra-chave 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 entre todas as instâncias da classe . Um método estático está sempre disponível. Todas as propriedades estáticas estão ativas para todo o intervalo de sessão.
O static palavra-chave só se aplica a membros de 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 que implemente essa interface.
Para obter mais informações sobre como derivar classes que herdam de uma classe base ou implementar interfaces, consulte about_Classes_Inheritance.
Afinidade de runspace
Um runspace é o ambiente operacional para os comandos invocados pelo PowerShell. Esse ambiente inclui os comandos e os dados que estão presentes no momento e todas as restrições de idioma que se aplicam atualmente.
Uma classe do PowerShell é afiliada ao Runspace em que ela é criada. O uso de uma classe do PowerShell no ForEach-Object -Parallel não é seguro.
As invocações de método na classe são colocadas de volta no Runspace em que ela foi criada, o que pode corromper o estado do Runspace ou causar um deadlock.
Para obter uma ilustração de como a afinidade de runspace pode causar erros, consulte Exemplo 4.
Exportando 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 using module instrução .
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.
Observação
Adicionar aceleradores de tipo à sessão usa uma API interna (não pública). O uso dessa 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 using module instrução à 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 $ExportableTypes variável contém cada um dos tipos que você deseja disponibilizar aos usuários quando eles importarem 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 o IntelliSense e a conclusão. Quando o módulo é removido, os aceleradores de tipo também são.
Importação manual de classes de um módulo do PowerShell
Import-Module e a instrução #requires só importam 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 using module instrução para importá-las.
A using module instrução 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 para o 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 using instrução, consulte about_Using.
Carregando código recém-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 using instrução não podem ser descarregadas.
Outra prática de desenvolvimento comum é separar o código em arquivos diferentes. Se você tiver função em um arquivo que usa classes definidas em outro módulo, deverá usar a using module instrução para garantir que as funções tenham as definições de classe necessárias.
O tipo PSReference não tem suporte com membros da classe
O [ref] acelerador de tipo é abreviado para a classe PSReference . Usar [ref] para digitar um membro de classe falha silenciosamente. APIs que usam [ref] parâmetros 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 de módulo.
As
hiddenpalavras-chave estaticse aplicam apenas aos membros da classe, não a uma definição de classe.Solução alternativa: nenhuma.
As classes do PowerShell não são seguras de usar em execução paralela entre runspaces. Quando você invoca métodos em uma classe, o PowerShell leva as invocações de volta para o Runspace em que a classe foi criada, o que pode corromper o estado do Runspace ou causar um deadlock.
Solução alternativa: nenhuma.
Limitações do construtor
O encadeamento do construtor não é implementado.
Solução alternativa: defina métodos ocultos
Init()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, cada sobrecarga do construtor também será tratada como oculta.
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
Update-TypeDatacmdlet .Os 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
Update-TypeDatacmdlet .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 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
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: nenhuma
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 do 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 diferente
.psm1e use ausing moduleinstrução para carregar o tipo. Não há solução alternativa para um tipo personalizado usar a si mesmo como o parâmetro de tipo ao herdar de um genérico.