about_Classes

Breve descrição

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 ampla gama de casos de uso.

Uma declaração de classe é um esquema 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 suportados

• 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 PowerShell.
• Defina atributos personalizados para decorar variáveis, parâmetros e definições de tipo personalizadas.
• Defina exceções personalizadas que podem ser capturadas pelo nome do tipo.

Sintaxe

Sintaxe da 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 da 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 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 trecho 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 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 trecho 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 Runspace

O ShowRunspaceId() método de relatórios diferentes Ids de thread, mas o mesmo ID de espaço de [UnsafeClass] execução. 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 [SafeClass] relatórios diferentes thread e Runspace ids.

# 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 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 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 deve 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 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 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 Get-Member cmdlet e não podem ser exibidos usando o preenchimento de tabulação ou o IntelliSense fora da definição de classe.

A hidden palavra-chave só se aplica aos 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 para a classe.
• Não incluído na lista de membros de classe retornados pelo Get-Member cmdlet. Para mostrar membros ocultos com Get-Member, use o parâmetro Force .
• Não exibido no preenchimento de tabulação ou no IntelliSense, a menos que a conclusão ocorra na classe que define o membro oculto.
• Membros públicos da turma. Eles podem ser acessados, herdados e modificados. Ocultar um membro não o torna privado. 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 em todas as instâncias da classe. Um método estático está sempre disponível. Todas as propriedades estáticas permanecem ativas durante toda a duração da sessão.

A static palavra-chave 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 oferece 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 espaço de execução é o ambiente operacional para os comandos invocados pelo PowerShell. Esse ambiente inclui os comandos e dados que estão presentes no momento, bem como quaisquer restrições de idioma atualmente aplicáveis.

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

Adicionar o NoRunspaceAffinity atributo à definição de classe garante que a classe PowerShell não seja afiliada a um espaço de execução 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 atual da sessão 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 quaisquer definições de tipo. Verifique se a $ExportableTypes variável contém cada um dos tipos que você deseja disponibilizar aos usuários quando eles importam 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.

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 dot-sourced para o 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 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, em seguida, 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 de 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 está a executar a versão mais recente, tem de iniciar uma nova sessão. As 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 seu código em arquivos diferentes. Se você tiver função em um arquivo que usa classes definidas em outro módulo, você deve usar a using module instrução para garantir que as funções tenham as definições de classe que são necessárias.

O tipo PSReference não é suportado com membros da classe

O [ref] acelerador de tipo é a abreviação da classe PSReference . O uso [ref] para digitar um membro da 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 suportar 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 tipo.

  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 torna os tipos disponíveis na importação de módulos.

• As hidden palavras-chave e static só se aplicam aos membros da classe, não a uma definição de classe.

  Alternativa: nenhuma.

• Por padrão, as classes do PowerShell não são seguras para uso na execução paralela em espaços de execução. Quando você invoca métodos em uma classe, o PowerShell organiza as invocações de volta para o Runspace onde a classe foi criada, o que pode corromper o estado do Runspace ou causar um impasse.

  Solução alternativa: adicione o NoRunspaceAffinity atributo à declaração de classe.

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 validação.

• Os parâmetros do construtor não podem definir valores padrão. Os parâmetros são sempre obrigatórios.

  Alternativa: nenhuma.

• Se qualquer sobrecarga de um construtor está oculta, cada sobrecarga para o construtor é tratada como oculta também.

  Alternativa: nenhuma.

Limitações do método

• Os parâmetros do 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 validation ou defina o método no construtor estático com o Update-TypeData cmdlet.

• Os parâmetros do 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 escondidos. Eles podem ser substituídos quando a classe é herdada.

  Alternativa: nenhuma.

• Se qualquer sobrecarga de um método estiver oculta, cada sobrecarga para esse método será tratada como oculta também.

  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.

  Alternativa: nenhuma.

• As propriedades não podem usar o atributo ValidateScript, porque os argumentos do atributo de propriedade de classe devem ser constantes.

  Solução alternativa: defina uma classe que herda do tipo ValidateArgumentsAttribute e use esse atributo em vez disso.

• As propriedades declaradas diretamente não podem definir implementações personalizadas de getter e setter.

  Solução alternativa: defina uma propriedade oculta e use Update-TypeData para definir a lógica getter e setter visível.

• As propriedades não podem usar o atributo Alias . O atributo só se aplica a parâmetros, cmdlets e funções.

  Solução alternativa: use o Update-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.

  Alternativa: nenhuma

Limitações de herança

• O PowerShell não oferece 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 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 genérica ou interface, 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 type ao herdar de um genérico.

Consulte 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