Classes do PowerShell: Começando

PowerShell é uma linguagem orientada a objetos. Quando você executa comandos, vê a saída na tela; esses são objetos. Objetos não surgem do nada; os desenvolvedores os criam ou, mais especificamente, os instanciam com classes. As classes do PowerShell representam definições ou esquemas desses objetos.

Embora você possa estar familiarizado com a criação de objetos usando comandos como New-Object e o uso do acelerador de tipo pscustomobject, esses não são objetos “novos”. Os tipos de objetos que esses métodos produzem são de um tipo específico. As classes do PowerShell definem o tipo.

Neste tutorial, você aprenderá como começar com as classes do PowerShell. Você criará sua primeira classe com construtores, aprenderá a criar objetos a partir de sua classe e personalizará sua classe com propriedades e métodos.

Para obter informações básicas sobre termos como objetos, propriedades e métodos, confira a postagem no blog Voltando às Origens: Compreendendo Objetos no PowerShell.

Pré-requisitos

Criando Sua Primeira Classe e Objeto

Antes de poder aprender todos os detalhes de uma classe do PowerShell, é recomendável primeiro criar uma classe simples. Tópicos mais avançados serão abordados mais tarde.

Criar sua primeira classe vai parecer um pouco com criar uma função. A sintaxe básica é a mesma. Uma classe é criada a partir de uma definição como uma função. Ao contrário das funções, porém, a primeira linha não começa com function seguida pelo nome da função, ela começa com class seguida pelo nome do seu tipo de objeto.

Relacionado:Seu Guia de Início Rápido para Funções do PowerShell

Abaixo você verá o esqueleto básico de uma classe chamada student.

class student {

}

Classes têm propriedades que se parecem com parâmetros que são atributos que descrevem essa classe. O exemplo abaixo mostra uma classe chamada student com duas propriedades; FirstName e LastName.

Ao definir uma propriedade, você deve sempre definir um tipo que estabeleça um “esquema” específico para o que os valores da propriedade podem conter. No exemplo abaixo, ambas as propriedades são definidas como strings.

Você sempre deve definir tipos de propriedade. Você verá o motivo depois.

class student {
    [string]$FirstName
    [string]$LastName
}

Depois de definir uma classe, crie um objeto a partir dela ou instancie um objeto. Existem várias maneiras de instanciar objetos a partir de classes; uma maneira comum é usar aceleradores de tipo como [student] que representam a classe, seguidos por um método padrão que vem com toda classe chamado new().

Usar o atalho do acelerador de tipo é o mesmo que criar um objeto usando o comando New-Object.

New-Object -TypeName student

Uma vez que você tenha criado um objeto dessa classe, atribua valores às propriedades. O exemplo abaixo está atribuindo os valores de Tyler e Muir para as propriedades FirstName e LastName.

class student {
    [string]$FirstName
    [string]$LastName
}
$student1 = [student]::new()
$student1.FirstName = 'Tyler'
$student1.LastName = 'Muir'
$student1

Depois de criar o objeto e atribuir valores às propriedades, inspecione o objeto chamando a variável à qual você atribuiu o objeto, como mostrado abaixo.

Agora que você criou um objeto de uma classe, encaminhe esse objeto assim como qualquer outro objeto no PowerShell para o cmdlet Get-Member para inspecioná-lo. Você pode ver abaixo que o objeto mantido dentro da variável $student1 é do tipo student.

O nome da classe sempre estará correlacionado com o tipo do objeto.

Observe que o Get-Member retorna quatro métodos e duas propriedades. As propriedades provavelmente parecem familiares, mas os métodos certamente não. O PowerShell adiciona certos métodos por padrão, mas você pode adicionar seus próprios métodos ou até mesmo modificar os métodos padrão.

Criando Métodos

No exemplo acima, você viu alguns métodos padrão no objeto, mas é provável que você queira criar os seus próprios. Para fazer isso, você deve definir um ou mais métodos dentro da definição da classe.

A method definition looks like below with an output type that defines what type of object is returned from this method, the name of the method, and the code to execute inside of a scriptblock.

[<output type>]<name>() {
	<code that runs when the method is executed>
}

Observe os parênteses () após o nome. É aqui que você pode definir os parâmetros do método (cobertos posteriormente). Os parâmetros do método permitem que você altere a funcionalidade de um método assim como pode fazer com os parâmetros de função.

Se você já escreveu e executou funções PowerShell antes, os blocos de script de método devem parecer familiares, mas há algumas regras especiais para métodos que você deve conhecer.

return é obrigatório

Funções PowerShell retornarão objetos simplesmente colocando o objeto em qualquer lugar na função, como no exemplo abaixo.

function foo {
	$object = Get-Service
	$object ## Apenas enviando o objeto para o pipeline
}

No entanto, ao contrário das funções, se um método retorna um objeto, você deve usar o construtor return, conforme mostrado abaixo.

[string]GetName() {
	return 'foo'
}

Usando a variável $this

Outra diferença que os métodos têm em relação às funções é a variável $this. A variável $this, conforme definida dentro de um método, faz referência às propriedades ou outros métodos do objeto atual.

Abaixo está um exemplo de um método chamado GetName() adicionado à classe student que concatena o valor das propriedades FirstName e LastName e os retorna.

class student {
    [string]$FirstName
    [string]$LastName
    
    [string]GetName() {
        return "$($this.FirstName) $($this.LastName)"
    }
}

Agora você pode chamar o método GetName() usando a notação de ponto, conforme mostrado abaixo. Se você atribuiu valores anteriormente a FirstName e LastName, GetName() irá retorná-los.

Adicionando Parâmetros aos Métodos

No exemplo acima, quando você executou a linha $student1.GetName(), você estava chamando o método GetName() como está. Dentro dos parênteses, você pode definir parâmetros da mesma forma que em funções.

O método GetName() apenas retornava os valores definidos para as propriedades FirstName e LastName. Mas e se você preferir ter um método para definir as propriedades que GetName() pode então obter? Nesse caso, você precisa definir os parâmetros do método.

Defina os parâmetros do método incluindo um ou mais parâmetros separados por vírgula entre os parênteses dos parâmetros do método, como mostrado abaixo.

Observe o tipo de saída [void]. Sempre que um método não produzir nada, você não precisa de uma construção return, e deve definir o tipo de saída como [void] para informar ao PowerShell que o método não retorna nada.

[void]SetName([string]$Name) {

}

Por exemplo, talvez o método SetName() aceite um nome completo (primeiro e último nome). Se for o caso, no scriptblock, você pode então dividir essa string e atribuir o primeiro e o último nome dessa forma.

Ao inserir o método SetName() na classe student, abaixo está como ele fica agora.

class student {
    [string]$FirstName
    [string]$LastName
    
    [string]GetName() {
        return "$($this.FirstName) $($this.LastName)"
    }
    
    [void]SetName([string]$Name) {
        $this.FirstName = ($Name -split ' ')[0]
        $this.LastName = ($Name -split ' ')[1]
    }
}

Agora você pode passar um nome completo como parâmetro para o método SetName(), que define as propriedades FirstName e LastName do objeto atual.

Sobrecarga de Métodos

Talvez você queira definir diferentes conjuntos de parâmetros para um método. Semelhante a como os conjuntos de parâmetros funcionam em funções e cmdlets, você pode definir diferentes “contextos” de parâmetro ou assinaturas de método.

Talvez você queira definir os parâmetros FirstName e LastName passando um nome completo para o método SetName() ou passando o primeiro e último nome separadamente. Você não precisa escolher; você pode defini-los ambos com as assinaturas de método correspondentes.

Ao definir mais de uma assinatura de método em uma classe, isso é chamado de sobrecarga.

Reutilizando o exemplo da seção anterior, você pode criar uma sobrecarga para o método SetName() para aceitar dois strings em vez de um. Quando você passa dois strings em vez de um, o método SetName() assume que o primeiro string é o FirstName e o segundo string é o LastName. Com essa sobrecarga, a classe ficaria assim.

class student {
    [string]$FirstName
    [string]$LastName
    
    [string]GetName() {
        return "$($this.FirstName) $($this.LastName)"
    }
    
    [void]SetName([string]$Name) {
        $this.FirstName = ($Name -split ' ')[0]
        $this.LastName = ($Name -split ' ')[1]
    }
    
    [void]SetName([string]$FirstName,[string]$LastName) {
        $this.FirstName = $FirstName
        $this.LastName = $LastName
    }
}

Construtores de Classe

Sempre que você instancia um objeto com o método new() ou de outra forma, você pode instruir o PowerShell a executar algum código definido pelo usuário chamado construtor. Construtores são como métodos, mas são executados automaticamente quando o PowerShell instancia um objeto.

Toda classe tem um construtor padrão. Este construtor padrão não faz muito; ele apenas instancia o objeto. Você pode ver o construtor padrão ao visualizar a saída do método New. Abaixo, você pode ver que esta linha retorna um único método new().

[student]::New

Sobrecarga de Construtor

Talvez você queira definir um valor para as propriedades FirstName e LastName assim que criar o objeto, não usando a notação de ponto típica. Nesse caso, você pode criar um construtor com um parâmetro que, em seguida, chama SetName().

Abaixo está um exemplo de um construtor para a classe student. Observe que o construtor não tem um nome específico ou é precedido por um tipo de saída. Construtores sempre usam o mesmo nome da classe.

Chamar um método existente no construtor nos permite reutilizar o método que já escrevemos para lidar com a definição das variáveis.

student([string]$Name) {
	$this.SetName($Name)
}

E abaixo você verá esse construtor adicionado à classe student.

class student {
    [string]$FirstName
    [string]$LastName
    
    student([string]$Name) {
        $this.SetName($Name)
    }

    [string]GetName() {
        return "$($this.FirstName) $($this.LastName)"
    }
    
    [void]SetName([string]$Name) {
        $this.FirstName = ($Name -split ' ')[0]
        $this.LastName = ($Name -split ' ')[1]
    }

    [void]SetName([string]$FirstName,[string]$LastName) {
        $this.FirstName = $FirstName
        $this.LastName = $LastName
    }
}

Quando você instanciar um novo objeto student e passar um parâmetro de string, as propriedades do objeto terão imediatamente os valores esperados.

Agora você pode ver novamente o construtor sobrecarregado com [student]::New. Observe agora que o novo construtor sobrecarregado é definido com um parâmetro Name.

Definindo um Construtor Padrão e Sobrecarregado

Agora que você tem um construtor sobrecarregado em sua classe student, o PowerShell sobrescreve o construtor padrão. Mas você pode recuperá-lo criando manualmente um sem parâmetros.

student() {}

Você pode ver como isso fica na classe student abaixo.

class student {
    [string]$FirstName
    [string]$LastName

    student([string]$Name) {
        $this.SetName($Name)
    }

    student() {}

    [void]SetName([string]$Name) {
        $this.FirstName = ($Name -split ' ')[0]
        $this.LastName = ($Name -split ' ')[1]
    }
}

Agora verifique os construtores novamente. Agora você verá ambos os construtores aparecerem.

[student]::New

Herança de Classe

Como todas as outras linguagens orientadas a objetos, você pode construir classes no PowerShell hierarquicamente com várias classes. Cada classe pode ter classes “pai” e “filho” que partem de propósitos menos específicos e mais genéricos, aumentando a especificidade.

Por exemplo, nossa classe student representa um estudante universitário (filho/específico). Esse estudante universitário é uma pessoa (pai/genérico). Esses dois conceitos estão relacionados e formam uma hierarquia.

A child class can inherit a parent class which means it can hold all properties and methods (members) defined via a parent class. We know that a person class may have properties like eye_color, height, and weight and perhaps a method called SetHeight().

Se um estudante é uma pessoa, esse estudante ainda possui essas propriedades e métodos. Seria duplicar esforços implementar esses mesmos membros na classe student que a classe person já possui. Você pode definir herança de classes para automaticamente definir todos os membros da classe person na classe student.

Se isso não faz sentido agora, fará enquanto percorremos uma demonstração.

Demonstração de Herança de Classes

Primeiro, faça uma cópia da classe student que você criou anteriormente, remova os construtores e renomeie para uma classe person. Sua classe person deve parecer com a classe abaixo.

A student, of course, has a first name and last name, but the class can be described more accurately by labeling it as a person. When creating a more “generic” class like this, you can create more specific “child” classes from it.

class person {
    [string]$FirstName
    [string]$LastName
    
    [string]GetName() {
        return "$($this.FirstName) $($this.LastName)"
    }
    
    [void]SetName([string]$Name) {
        $this.FirstName = ($Name -split ' ')[0]
        $this.LastName = ($Name -split ' ')[1]
    }

    [void]SetName([string]$FirstName,[string]$LastName) {
        $this.FirstName = $FirstName
        $this.LastName = $LastName
    }
}

Agora, crie algumas classes que representam uma pessoa, mas têm um papel mais específico. Por exemplo, no trecho de código abaixo, agora você tem uma classe teacher e student.

class teacher {
    [int]$EmployeeId
}

class student {
    [int]$StudentId
}

Como está, as classes teacher e student são mutuamente exclusivas da classe person. Elas não têm relação, mas não podem herdar nenhum membro da classe person. Vamos mudar isso.

Agora defina essa hierarquia ao definir as classes teacher e student como classes “filhas” da classe person com herança. Você pode definir a herança acrescentando dois pontos (:) após o nome da classe, seguido pelo nome da classe pai, conforme mostrado abaixo.

class teacher : person {
    [int]$EmployeeId
}

class student : person {
    [int]$StudentId
}

Agora, seu script de classe completo deve se parecer com isso:

class person {
    [string]$FirstName
    [string]$LastName
    
    [string]GetName() {
        return "$($this.FirstName) $($this.LastName)"
    }
    
    [void]SetName([string]$Name) {
        $this.FirstName = ($Name -split ' ')[0]
        $this.LastName = ($Name -split ' ')[1]
    }

    [void]SetName([string]$FirstName,[string]$LastName) {
        $this.FirstName = $FirstName
        $this.LastName = $LastName
    }
}

class teacher : person {
    [int]$EmployeeId
}

class student : person {
    [int]$StudentId
}

Neste ponto, ao instanciar um objeto a partir da classe teacher ou student, ambas as classes terão os mesmos membros da classe person.

Herança com Construtores

Como visto anteriormente, os métodos de classe são herdados por meio da herança de classe. Esse comportamento pode levá-lo a pensar que os construtores seguiriam a mesma lógica, mas você estaria errado. Os construtores não são herdados, e os construtores de todas as classes filhas devem ser definidos em cada classe filha separadamente.

Por exemplo, talvez você tenha acabado de definir um construtor sobrecarregado para a classe person, mas não definiu um construtor para a classe teacher, como mostrado abaixo.

class person {
    [string]hidden $FirstName
    [string]$LastName
    
    [string]GetName() {
        return "$($this.FirstName) $($this.LastName)"
    }
    
    [void]SetName([string]$Name) {
        $this.FirstName = ($Name -split ' ')[0]
        $this.LastName = ($Name -split ' ')[1]
    }

    [void]SetName([string]$FirstName,[string]$LastName) {
        $this.FirstName = $FirstName
        $this.LastName = $LastName
    }

		person([string]$Name) {
			$this.SetName($Name)
		}
}

Então você define uma classe filha, teacher, por exemplo, e tenta criar um objeto sem parâmetros a partir dela, como mostrado abaixo. Observe que o PowerShell retorna um erro porque um construtor sem parâmetros não foi definido dentro da classe teacher.

A constructor is not necessary in a child class if you’re only using it as a template. Alternatively, if you want to use the parent class as its own standalone class and as a parent class you can include constructors. But you have to make sure that the parent class has a constructor that matches the ones in the child classes.

Atributos de Membros da Classe

Assim como os parâmetros de comandos do PowerShell, as classes podem ter atributos de membros. Esses atributos modificam o comportamento de cada membro.

Membros Ocultos

Se estiver usando um membro de classe apenas para fins internos e não deseja que o usuário leia ou escreva nele, você pode definir um membro como oculto. Por exemplo, talvez você tenha um método que é usado apenas por outros métodos. Não há necessidade de expor esse método ao usuário.

Para definir um membro oculto, use o atributo hidden conforme mostrado abaixo.

class teacher {
    [int]hidden $EmployeeId
}

Agora, ao usar Get-Member para inspecionar todos os membros do objeto, essa propriedade não aparece.

Definir um membro de classe como oculto não restringe o acesso ao valor; apenas o oculta da vista. Você não deve ocultar propriedades para armazenar dados sensíveis.

Membros Estáticos

Lembre-se anteriormente; este tutorial usava o termo “instanciar” para descrever a criação de um objeto a partir de uma classe. Quando você instancia um objeto, esse objeto assume todas as propriedades e métodos que a classe define. Mas nem sempre é o caso.

Às vezes, você não precisa da sobrecarga de instanciar um objeto inteiro. Em vez disso, você precisa fazer referência a um único membro de classe rapidamente. Nesse caso, você pode definir um membro de classe como estático.

Assim como com o atributo hidden, defina um membro de classe como estático usando a palavra-chave static conforme mostrado abaixo.

class student {
	[int]static $MaxClassCount = 7
}

Ao contrário dos membros de classe típicos, o PowerShell não cria propriedades e métodos a partir de membros de classe estáticos. Quando você define um membro de classe como estático, como membros ocultos, ele não aparece quando você usa Get-Member.

Por exemplo, talvez você queira associar os nomes das classes universitárias com a classe student e definir o número máximo de classes universitárias que um aluno pode participar. Para fazer isso, você cria um membro de array Classes e um membro MaxClassCount.

Como o usuário raramente precisa alterar o membro MaxClassCount, você decide defini-lo como estático.

Finalmente, você cria um método AddClass() para adicionar uma classe à grade do aluno, mas somente se for menor que MaxClassCount.

class student {
    [string[]]$Classes = @()
    [int]static $MaxClassCount = 7
    
    [void]AddClass ([string]$Name) {
        if ($this.Classes.Count -lt [student]::MaxClassCount) {
            $this.Classes += $Name
        }
    }
}

Agora, ao tentar criar um novo objeto student e atribuir muitas classes universitárias a ele, o PowerShell atribuirá apenas o número máximo, que seria sete.

$student1 = [student]::new()
'PE','English','Math','History','Computer Science','French','Wood Working','Cooking' | ForEach-Object {
	$student1.AddClass($_)
}
$student1.Classes

Você pode alterar os valores dos membros estáticos a qualquer momento. Se, por exemplo, quiser definir o membro MaxClassCount como 5 em vez de 7, você mudaria o valor usando [student]::MaxClassCount = 5. Alterar o valor não removeria retroativamente as classes que estão acima do limite neste exemplo.

Conclusão

As classes do PowerShell borram a linha entre uma linguagem de script e uma linguagem de programação. As classes são uma ótima maneira de definir relacionamentos entre objetos, adicionar formas de interagir e formatar objetos que normalmente só seriam possíveis escrevendo funções especializadas.