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>]}

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:

Exception:
Line |
  84 |              throw "Book '$Book' already in list"
     |              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     | Book 'The Hobbit by J.R.R. Tolkien (1937)' already in list

Exemplo 4 - Definição de classe com e sem afinidade de Runspace

O ShowRunspaceId() método de relata IDs de thread diferentes, mas a mesma ID de [UnsafeClass] 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($_)
    }
}

O ShowRunspaceId() método de relatórios diferentes IDs de [SafeClass] 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($_)
    }
}

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-Member cmdlet. Para mostrar membros ocultos com Get-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.

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.

Atributo NoRunspaceAffinity

Um runspace é o ambiente operacional para os comandos invocados pelo PowerShell. Esse ambiente inclui os comandos e dados que estão presentes no momento e quaisquer restrições de idioma que se aplicam no momento.

Por padrão, uma classe do PowerShell é afiliada ao Runspace em que ela é criada. Usar uma classe do PowerShell não ForEach-Object -Parallel é seguro. As invocações de método na classe são enviadas de volta para o Runspace em que foram criadas, o que pode corromper o estado do Runspace ou causar um deadlock.

Adicionar o NoRunspaceAffinity atributo à definição de classe garante que a classe do PowerShell não seja afiliada a um runspace específico. As invocações de método, tanto de instância quanto estáticas, usam o Runspace do thread em execução e o estado de 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 NoRunspaceAffinity 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 depois que os usuários importarem o módulo.

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 hidden palavras-chave e static se aplicam apenas a membros da classe, não a uma definição de classe.

  Solução alternativa: Não há.

• Por padrão, as classes do PowerShell não são seguras para uso na execução paralela entre runspaces. Quando você invoca métodos em uma classe, o PowerShell realiza 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: adicione o NoRunspaceAffinity atributo à declaração de classe.

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-TypeData cmdlet.

• 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-TypeData cmdlet.

• 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-TypeData para 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-TypeData cmdlet para definir aliases nos construtores de classe.

• Quando uma classe do PowerShell é convertida em JSON com o ConvertTo-Json cmdlet, 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 .psm1 e use a using module instruçã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.

Confira também

• about_Classes_Constructors
• about_Classes_Inheritance
• about_Classes_Methods
• about_Classes_Properties
• about_Enum
• about_Hidden
• about_Language_Keywords
• about_Methods
• about_Using