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 instância do tipo Device. Cada instância de Device pode ter valores diferentes em suas propriedades.
Cenários com suporte
- Defina tipos personalizados no PowerShell usando semântica de programação orientada a objetos, 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 do 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 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 da tabela de hash só funciona para classes que têm um construtor padrão que não espera nenhum parâmetro. Ele cria uma instância da classe com o construtor padrão e, em seguida, atribui os pares chave-valor às propriedades da instância. Se alguma 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 and 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 se baseia na classe Book no exemplo 2. 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:
Book 'The Hobbit by J.R.R. Tolkien (1937)' already in list
At C:\code\classes.examples.ps1:114 char:13
+ throw "Book '$Book' already in list"
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ CategoryInfo : OperationStopped: (Book 'The Hobbi...alread
y in list:String) [], RuntimeException
+ FullyQualifiedErrorId : Book 'The Hobbit by J.R.R. Tolkien (1937)'
already in list
Propriedades de classe
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 usar 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 que você defina valores padrão e valide a lógica do objeto no momento da criação da instância da classe. Os 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 hidden palavra-chave oculta um membro da classe. O membro ainda está acessível ao usuário e está disponível em todos os escopos em que o objeto está disponível.
Os membros ocultos ficam ocultos do cmdlet e não podem ser exibidos usando o Get-Member preenchimento de tabulação ou o IntelliSense fora da definição de classe.
A hidden palavra-chave se aplica apenas a membros da classe, não a uma classe em si.
Os membros ocultos da classe 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 membros ocultos 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 o membro oculto.
- Membros públicos da classe. Eles podem ser acessados, herdados e modificados. Ocultar um membro não o torna privado. Ele apenas oculta o membro conforme descrito nos pontos anteriores.
Observação
Quando você oculta qualquer sobrecarga para um método, esse método é removido do IntelliSense, dos resultados de conclusão e da saída padrão do Get-Member.
Quando você oculta qualquer construtor, a opção é removida do IntelliSense e os new() 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 static palavra-chave define uma propriedade ou um método que existe na classe e não precisa de instância.
Uma propriedade estática está sempre disponível, independentemente 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 residem durante todo o período da sessão.
A static palavra-chave se aplica apenas a 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 derivada 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 acontecer, a classe poderá 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.
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 depois que os usuários importarem o módulo.
Observação
A adição de 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 ou a conclusão ao criar um arquivo de script no VS Code.
Para obter sugestões de IntelliSense e 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. Certifique-se de que a $ExportableTypes variável contenha cada um dos tipos que você deseja disponibilizar aos usuários quando eles importarem o módulo. O outro código não requer nenhuma 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.
Importando manualmente classes de um módulo do PowerShell
Import-Module e a #requires instrução importa apenas as funções, aliases e 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á-los.
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 originados por pontos no módulo raiz. Defina as classes que você deseja que estejam disponíveis para usuários fora do módulo diretamente no módulo raiz.
Para obter mais informações sobre a instrução, consulte about_Usingusing.
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 o parâmetro Force . Recarregar o módulo só funciona para alterações nas funções no módulo raiz. Import-Module não recarrega nenhum módulo aninhado. Além disso, não há como carregar nenhuma classe atualizada.
Para garantir que você esteja executando a versão mais recente, você deve iniciar 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 comum de desenvolvimento é separar seu código em arquivos diferentes. Se você tiver uma função em um arquivo que usa classes definidas em outro módulo, use a using module instrução 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 [ref] acelerador de tipo é uma abreviação para a classe PSReference . O uso [ref] de conversão de tipo de um membro de classe falha silenciosamente. As 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. Os 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: Não há.
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 torna os tipos disponíveis na importação do módulo.
As
hiddenpalavras-chave estaticse aplicam apenas a membros da classe, não a uma definição de classe.Solução alternativa: Não há.
Limitações do construtor
O encadeamento de construtores 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: Não há.
Se qualquer sobrecarga de um construtor estiver oculta, todas as sobrecargas do construtor também serão tratadas como ocultas.
Solução alternativa: Não há.
Limitações do 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: Não há.
Se qualquer sobrecarga de um método estiver oculta, todas as sobrecargas desse método também serão tratadas como ocultas.
Solução alternativa: Não há.
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: 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á
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 faça referência ao 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 type para o genérico já deve estar 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.
