Windows PowerShell é um ambiente de comandos que suporta scripting orientado a objectos baseado no Microsoft .NET Framework. Em seu coração está o PowerShell cmdlet, um comando leve que executa uma ação específica e, no processo, retorna um objeto .NET. O PowerShell permite que você use cmdlets para acessar uma variedade de sistemas e executar inúmeras tarefas contra esses sistemas. No entanto, as cmdlets por si só nem sempre são suficientes para realizar determinadas acções. Para essas ações, você deve freqüentemente criar seus próprios objetos com base nas classes .NET. Um tipo de objeto .NET que você pode construir é o objeto personalizado. Um objeto personalizado permite definir os tipos de dados atribuídos a esse objeto e as ações que ele pode executar. Depois de compreender como construir um objecto personalizado, terá uma ferramenta poderosa para construir scripts que pode estender o alcance já significativo do PowerShell.
Note que o .NET Framework e a programação orientada a objectos são tópicos complexos, muito para além do âmbito aqui. Para apreciar plenamente a natureza orientada a objetos do PowerShell, pode ajudar a ter pelo menos uma compreensão básica desses conceitos. Para mais informações sobre o .NET Framework, veja o artigo MSDN “Overview of the .NET Framework”. Para uma introdução à programação orientada a objectos, veja o artigo MSDN “Programação Orientada a Objectos (C# e Visual Basic)”
Criar um Objecto Personalizado
Para criar um objecto personalizado no PowerShell, deve primeiro usar a cmdlet New-Object para construir o objecto inicial. Este cmdlet permite-lhe criar objectos .NET ou COM a partir de um conjunto de classes. Um objecto personalizado é um tipo especial de objecto .NET baseado na classe Object ou PSObject .NET. Não há diferença entre os dois ao criar o objeto inicial. Entretanto, a classe PSObject é geralmente preferida por causa de problemas que podem surgir ao adicionar propriedades a um objeto baseado na classe Object, então vamos usar PSObject.
Para criar um objeto baseado na classe PSObject, você precisa usar o cmdlet New-Object com o parâmetro -TypeName e especificar a classe PSObject como o valor do parâmetro, assim:
$system = New-Object -TypeName PSObject
Quando você executar este comando, ele irá gerar um objeto PSCustomObject e atribuí-lo à variável $system. Na maioria das vezes, você vai querer atribuir o objeto a uma variável para que você possa trabalhar facilmente com os membros desse objeto. Os membros são os componentes que compõem um objecto, tais como propriedades, métodos, propriedades alias, e conjuntos de membros.
Ao trabalhar com objectos no PowerShell, os dois tipos de membros que irá provavelmente usar são propriedades e métodos. Uma propriedade descreve um aspecto específico do objeto. Por exemplo, um dos membros da classe FileInfo .NET é a propriedade Length, que fornece o tamanho de um arquivo em bytes. Se você criar um objeto FileInfo com base nessa classe, você pode usar a propriedade Length para acessar o tamanho do arquivo associado a esse objeto. Um método executa uma acção relacionada com o objecto. Por exemplo, a classe FileInfo também inclui o método Delete, que você pode usar para apagar o arquivo representado pelo objeto.
Ser capaz de identificar facilmente os membros de um objeto facilita o trabalho com esse objeto. Para obter uma lista dos membros que compõem um objeto, você pode usar a opção Get-Member cmdlet. Por exemplo, para olhar os membros do novo objeto que foi atribuído à variável $system, você pode pipear a variável $system para a variável Get-Member cmdlet:
$system | Get-Member
Como mostra a Figura 1, o objeto que você criou é baseado na classe System.Management.Automation.PSCustomObject, que inclui apenas um pequeno número de membros, todos os quais são métodos. Mas é por isso que é chamado de objeto customizado – você pode customizá-lo adicionando seus próprios membros.
Before I show you how to add members, let me just add that, like many .NET classes, the PSCustomObject class also includes a number of hidden members of various types, such as memberset and codeproperty. Você pode ver esses membros incluindo o parâmetro -Force quando chamar a opção Get-Member cmdlet. Embora uma discussão sobre membros ocultos esteja além do escopo aqui, você pode achar útil em algum momento explorar os membros ocultos disponíveis para a classe PSCustomObject e outras classes .NET para tirar total proveito dos seus objetos PowerShell.
Adicionando propriedades a um objeto personalizado
Um objeto personalizado só é tão útil quanto os membros associados ao objeto. Você pode adicionar vários tipos diferentes de membros a um objeto personalizado. Para este exemplo, você irá adicionar os membros NoteProperty e ScriptMethod. Um membro NoteProperty é semelhante a uma propriedade regular, e um membro ScriptMethod é muito semelhante a um método regular. Você não pode adicionar uma propriedade regular ou um método a um objeto personalizado, e é por isso que você vai usar a NoteProperty e o ScriptMethod. (Para informações sobre os membros suportados num objecto personalizado, veja o tópico PowerShell TechNet “Add-Member”)
Comecemos por adicionar um par de membros da NoteProperty ao objecto $system. Para adicionar os membros, você pode usar o Add-Member cmdlet para definir os nomes e valores das propriedades. Por exemplo, suponha que quer adicionar propriedades de notas baseadas em dados recuperados através das capacidades do Windows Management Instrumentation (WMI) incorporadas no PowerShell. (A WMI fornece uma infra-estrutura para gerenciar dados e operações em sistemas operacionais Windows). O modelo de objeto WMI inclui numerosas classes que suportam uma ampla gama de operações de gerenciamento. Por exemplo, a classe Win32_OperatingSystem fornece acesso a informações como o nome do SO instalado em um computador e o último service pack aplicado a esse SO.
Para criar um objeto WMI, você usa a cmdlet Get-WmiObject e especifica a classe desejada. Por exemplo, para criar um objeto WMI Win32_OperatingSystem e atribuí-lo à variável $os, você usaria o código:
$os = Get-WmiObject Win32_OperatingSystem
Neste caso, você está recuperando informações do sistema do computador local, mas a beleza do WMI é sua habilidade de também acessar e gerenciar computadores Windows remotos.
Você pode então usar a variável $os para acessar as informações retornadas por aquele objeto. Atribuir um objeto a uma variável desta forma bloqueia os dados naquele momento. Por exemplo, se um novo service pack for aplicado ao SO depois de criar a variável $os, a propriedade CSDVersion do objeto não refletirá a mudança porque o objeto foi criado baseado nos dados originais.
Após definir a variável $os, você precisa especificar dois comandos Add-Member. Cada comando terá quatro parâmetros:
- -InputObject. Você usa o parâmetro -InputObject para identificar o objeto que recebe as novas propriedades da nota. Neste caso, você precisa especificar o objeto $system.
- -MemberType. O parâmetro -MemberType indica o tipo de membro a criar, por isso precisa de especificar NoteProperty.
- -Name. Você utiliza o parâmetro -Name para especificar o nome do novo membro. Para este exemplo, vamos nomear o primeiro membro OperatingSystem e o segundo membro ServicePack.
- -Value. Este parâmetro especifica o valor do membro. Para a propriedade da primeira nota, você precisa especificar $os.Caption para retornar o nome do SO. Para a propriedade da segunda nota, você precisa especificar $os.CSDVersion para retornar o último service pack aplicado ao OS.
Aqui está como os dois comandos Add-Member são:
Add-Member -InputObject $system -MemberType NoteProperty ` -Name OperatingSystem -Value $os.CaptionAdd-Member -InputObject $system -MemberType NoteProperty ` -Name ServicePack -Value $os.CSDVersion
Notice que eu quebrei cada comando Add-Member em duas linhas. No final de cada primeira linha, incluí um tick de retorno (`) para que o processador PowerShell saiba continuar para a próxima linha para o comando completo.
Após ter executado os comandos Add-Member, você pode chamar a variável $system para ver seu conteúdo:
$system
Figure 2 mostra resultados de exemplo.
Você também pode usar a variável $system para chamar membros individuais. Basta especificar o nome da variável, seguido por um ponto e depois o nome do membro. Por exemplo, o seguinte comando retorna o valor actual da propriedade OperatingSystem note:
$system.OperatingSystem
Uma vantagem de criar um objecto personalizado é que lhe permite criar propriedades de nota baseadas em dados que vêm de diferentes fontes, bem como uma propriedade de nota cujo valor é uma string específica. Por exemplo, veja o código na Listagem 1, que adiciona três novas propriedades de nota ao objecto $system.
$mem = Get-WmiObject Win32_PhysicalMemory$disk = Get-WmiObject Win32_DiskDriveAdd-Member -InputObject $system -MemberType NoteProperty ` -Name PhysicalMemory ` -Value (("{0:N2}" -f ($mem.Capacity/1GB)) + ' GB')Add-Member -InputObject $system -MemberType NoteProperty ` -Name DiskSize ` -Value (("{0:N2}" -f ($disk.Size/1GB)) + ' GB')Add-Member -InputObject $system -MemberType NoteProperty ` -Name Owner -Value "janetp"
Maior parte dos elementos da Listagem 1 que viu no exemplo anterior. No entanto, observe que o código está criando uma instância da classe Win32_PhysicalMemory, que é atribuída à variável $mem, e uma instância da classe Win32_DiskDrive, que é atribuída à variável $disk. Duas das propriedades de notas adicionadas utilizam estes novos objectos WMI como fontes de dados.
O primeiro comando Add-Member recupera dados da propriedade $mem.Capacity, que fornece a capacidade da memória no sistema alvo. Neste caso, entretanto, o parâmetro -Valor é um pouco mais complexo do que você viu no exemplo anterior. Primeiro, o comando especifica “{0:N2}” seguido por -f, que é uma construção .NET para formatar o número de saída. Basicamente, isto especifica que um número deve ser retornado com duas casas decimais. As instruções de formatação são seguidas por uma breve expressão ($mem.Capacity/1GB) que divide o valor da Capacidade por 1GB. O valor de Capacidade fornece o tamanho da memória em bytes. PowerShell facilita a conversão de bytes em gigabytes simplesmente dividindo por 1GB. Finalmente, o comando marca a string ‘ GB’ (incluindo o espaço) na saída e encerra tudo entre parênteses.
O segundo comando Add-Member segue a mesma lógica para retornar o tamanho do disco rígido do computador. Ele usa a propriedade $disk.Size para retornar o tamanho em bytes, depois converte-o para gigabytes.
O terceiro comando Add-Member adiciona uma propriedade Note chamada Owner e atribui a ela o valor da string janetp. Neste caso, “dono” pode significar qualquer coisa – o utilizador primário, o último utilizador, o administrador, ou qualquer outro significado que queira impor à propriedade. Incluí-a aqui apenas para demonstrar que pode adicionar uma propriedade note cujo valor é uma simples string.
Depois de adicionar os três membros ao objecto personalizado, pode mais uma vez chamar a variável $system. Ela retornará resultados como os mostrados na Figura 3.
Você agora tem um único objeto que contém dados derivados de três objetos WMI diferentes. O objeto também contém a propriedade Owner, que é baseada em um valor de string. Você pode chamar essa propriedade de nota como chamaria qualquer outro membro:
$system.Owner
Como você esperaria, o comando retorna o valor janetp. No entanto, pode alterar esse valor para um diferente atribuindo um novo valor à propriedade, como assim:
$system.Owner = "rogert"
Neste caso, o valor rogert foi atribuído à propriedade Owner note. Se chamar essa propriedade nota agora, ela irá devolver o novo valor.
Tal como com muitas das tarefas que pode executar no PowerShell, existem várias formas diferentes de adicionar um membro a um objecto personalizado. Por exemplo, o PowerShell 3.0 permite-lhe criar uma tabela hash e passar o hash para o comando New-Object. O código em Listing 2 cria as mesmas cinco propriedades de nota mas usa uma tabela hash para passar os nomes e valores dos membros.
$info = @{ "OperatingSystem" = $os.Caption; "ServicePack" = $os.CSDVersion; "PhysicalMemory" = (("{0:N2}" -f ($mem.Capacity/1GB)) + ' GB'); "DiskSize" = (("{0:N2}" -f ($disk.Size/1GB)) + ' GB'); "Owner" = 'janetp'}$system = New-Object -TypeName PSObject -Property $info$system
Este código primeiro cria uma tabela hash que define cinco pares de propriedades/valor, cada um correspondendo às propriedades da nota. Como o código mostra, você precisa separar os pares de propriedades/valores com ponto-e-vírgula. Você também precisa anexar o conjunto de cinco pares de propriedades/valores entre colchetes e preceder o par de abertura com o símbolo at (@). Finalmente, você precisa atribuir a tabela hash à variável $info.
Após definir a tabela hash, o código usa o cmdlet New-Object para criar um objeto baseado na classe PSObject e o atribui à variável $system. Somente desta vez, o comando inclui o parâmetro -Property, que toma a variável $info como seu valor.
Finalmente, o código chama a variável $system, que retorna resultados como os da Figura 4. Observe a ordem na qual as propriedades foram adicionadas ao objeto. Um dos problemas em usar uma tabela hash para adicionar propriedades de notas é que você não pode controlar a ordem delas. Para controlar a ordem, você deve usar o Add-Member cmdlet para adicionar cada membro.
Adding Methods to a Custom Object
Agora que você já viu como é fácil adicionar propriedades, acessar seus valores e alterar esses valores, vamos passar para métodos. Estes se tornam um pouco mais complicados porque os métodos têm que fazer algo, e você precisa definir esse algo como parte do valor do método.
Por exemplo, o código na Listagem 3 cria um método que recupera a data e hora atual e os retorna tanto em seu formato original quanto como valores de Tempo Universal Coordenado (UTC).
$method ={ $a = Get-Date -Format F; "Local: " + $a; $b = Get-Date; "UTC: " + $b.ToUniversalTime().DateTime}Add-Member -InputObject $system -MemberType ScriptMethod ` -Name GetUTC -Value $method
Para manter o código legível, você pode atribuir o valor do método a uma variável (por exemplo, $method). Esse valor inclui as expressões necessárias para retornar a informação de data e hora. No entanto, você deve definir o valor como um bloco de script a fim de passá-lo para o comando Add-Member. Para fazer isso, você inclui o conteúdo do valor entre parênteses curvos. PowerShell irá então atribuir o valor na sua forma actual à variável como um objecto ScriptBlock.
Na Listagem 3, o valor do método inclui duas expressões. A primeira expressão retorna a data e hora atual, e a segunda expressão retorna a versão UTC. Você inicia a primeira expressão usando o Get-Date cmdlet para recuperar a data e a hora atual, que você atribui à variável $a. Note que quando você chama o Get-Date cmdlet, você precisa incluir o parâmetro -Format, junto com o valor F. Isto diz ao PowerShell para exibir o carimbo da hora e data completos, como na segunda-feira, 19 de agosto de 2013 12:28:25 PM. Você então adiciona a string “Local: ” (incluindo o espaço) ao valor da variável para retornar a data e hora atual junto com aquela etiqueta.
Na segunda expressão, você começa novamente com o cmdlet Get-Date para retornar a data e hora atual, que você atribui à variável $b. Você então usa o método ToUniversalTime da variável para retornar a data e a hora como um valor UTC, depois especifica a propriedade DateTime para retornar o formato correto.
Se você fosse chamar a variável $method neste ponto, ela retornaria as duas expressões como strings, exatamente como foram digitadas. Como você definiu o valor da variável como um bloco de script, os comandos não são processados quando são atribuídos à variável $method. Ao invés disso, a variável $method é criada como um objeto ScriptBlock, que você pode confirmar usando o método GetType para ver o tipo da variável:
$method.GetType()
Para trabalhar com o bloco de script, você precisa adicionar o método como um membro do objeto $system depois de definir a variável $method. Para fazer isso, você cria um comando Add-Member que especifica ScriptMethod como o tipo, GetUTC como o nome, e a variável $method como o valor.
Após executar o código na Listagem 3, você pode usar a variável $system para chamar o método GetUTC da mesma forma que você chamou as propriedades:
$system.GetUTC()
Note, no entanto, que quando você chama o método script, você deve incluir os parênteses, assim como você faz para qualquer outro método, mesmo que você não esteja passando em argumentos. O método deve agora retornar resultados similares aos da Figura 5 mas com a data e hora em que você chamou o método.
Na vida real, você provavelmente vai querer criar métodos que embalem mais ponche. Por exemplo, o objeto $system pode incorporar tarefas de gerenciamento do WMI em seus métodos de script. Se você fizer isso, você precisa testar completamente o método para ter certeza que seus comandos estão fazendo exatamente o que eles devem fazer. PowerShell e WMI são ambas ferramentas poderosas, por isso devem ser usadas com cuidado ao gerenciar computadores Windows.
Adicionando Objetos Personalizados a um Array
Os objetos personalizados não estão limitados a objetos autônomos que você usa uma vez e joga de lado. Você pode adicionar esses objetos a um array de objetos, e então acessar os objetos através desse array. Por exemplo, suponha que você queira manipular a informação que você recupera de vários computadores. Essa informação pode incluir detalhes sobre a memória e as unidades lógicas disponíveis nesses sistemas. Você quer ser capaz de trabalhar com esses detalhes de uma forma significativa no PowerShell. Devido à natureza orientada a objectos do PowerShell, colocar essa informação em objectos é muitas vezes a forma mais simples de trabalhar com esses dados.
Vejamos um exemplo de como o pode fazer. Para esta discussão, a abordagem utilizada para recolher a informação sobre os vários computadores não é importante. Você pode, por exemplo, configurar um loop foreach no PowerShell que usa o WMI para recuperar as informações das diferentes estações de trabalho. Independentemente do método utilizado, por uma questão de brevidade, suponha que você tenha coletado as informações em um arquivo de texto separado por vírgulas que contém os dados mostrados na Figura 6.
O arquivo de texto inclui uma linha de cabeçalho e uma linha para as unidades lógicas de cada sistema. Por exemplo, a primeira linha de dados fornece detalhes sobre o disco lógico C no computador ws01. O disco lógico tem uma capacidade de 500GB, com 225GB de espaço livre. O sistema também tem 4GB de memória. A segunda linha indica que o mesmo computador também contém a unidade lógica D, que tem a mesma capacidade que a unidade C mas com 320GB de espaço livre.
O objetivo é transformar cada linha de dados em seu próprio objeto personalizado, depois adicionar esses objetos a uma matriz. Você pode então tomar medidas sobre os objetos dentro do array, piping os dados para outros comandos PowerShell. O código em Listing 4 define um array vazio, importa os dados do arquivo de texto, então usa um loop foreach para criar os objetos e adicioná-los ao array.
$SystemInfo = @()$SourceData = Import-CSV C:\DataFiles\SourceData.txtforeach ($source in $SourceData){ $system = New-Object -TypeName PSObject $system | Add-Member -Type NoteProperty ` -Name Computer -Value $source.Computer $system | Add-Member -Type NoteProperty ` -Name DeviceID -Value $source.DeviceID $system | Add-Member -Type NoteProperty ` -Name DriveSize -Value ($source.DriveSize) $system | Add-Member -Type NoteProperty ` -Name UsedSpace ` -Value ($source.DriveSize - $Source.FreeSpace) $system | Add-Member -Type NoteProperty ` -Name FreeSpace -Value ($source.FreeSpace) $SystemInfo += $system}
Como você pode ver, o primeiro passo é criar o array vazio (@()) e atribuí-lo à variável $SystemInfo. Eventualmente, você adicionará os objetos personalizados a este array.
Next, você usa o cmdlet Import-CSV para importar os dados para a variável $SourceData. Para este exercício, o arquivo de texto é chamado SourceData.txt e salvo na pasta C:\DataFiles. O cmdlet Import-CSV cmdlet recupera cada linha como seu próprio objeto, salvando-a para $SourceData. Neste ponto, você poderia usar essa variável para acessar os dados, mas você não teria controle sobre os membros incluídos no objeto, nem seria capaz de adicionar membros.
O próximo passo, então, é criar um loop foreach que lhe permite criar um objeto personalizado para cada linha no arquivo de texto. A condição foreach ($source em $SourceData) especifica que cada linha em $SourceData deve ser atribuída à variável $source como o código que itera através do laço foreach. A lógica definida dentro do bloco do script foreach (entre colchetes) será então executada uma vez para cada linha, com um objeto $source diferente sendo aplicado durante cada iteração. (Para mais informações sobre como criar um loop de foreach, veja o tópico PowerShell TechNet sobre_ForEach.)
Vamos dar uma olhada mais de perto no bloco do script de foreach. O primeiro comando cria o objeto inicial e o salva na variável $system, como você viu em exemplos anteriores. De seguida, a variável $system é canalizada para um comando Add-Member de modo a criar a propriedade first note. Este é um formato ligeiramente diferente do usado anteriormente. Ao invés de incluir o parâmetro -InputObject no comando Add-Member, você simplesmente pipeia o $system para o comando. Isto alcança os mesmos resultados que você viu nos exemplos anteriores de comandos Add-Member. Eu tomei esta abordagem aqui simplesmente para demonstrar mais uma maneira que o PowerShell permite adicionar membros.
Para o valor do comando Add-Member, você usa a variável $source para chamar a propriedade Computer, que corresponde ao campo Computer nos dados de origem. O segundo comando Add-Member funciona da mesma maneira, exceto que ele recupera dados da propriedade DeviceID. Note que a propriedade Memória não está incluída. Quando você está criando um objeto personalizado, você pode omitir propriedades específicas ou colocá-las em uma ordem diferente.
O terceiro comando Add-Member funciona da mesma forma que os dois primeiros, exceto que ele está acessando a propriedade DriveSize. Como você pode querer trabalhar com esses dados como um valor numérico ao invés de uma string, o comando converte explicitamente os dados para um número. Isto é conseguido ao preceder o nome da propriedade com para indicar que você quer o tipo de dadoint, e depois anexar toda a expressão da propriedade entre parênteses.
O quarto comando Add-Member faz algo um pouco diferente. Ele cria um membro calculado que subtrai o valor FreeSpace do valor DriveSize a fim de determinar a quantidade de espaço usado. Novamente, o nome da propriedade é precedido e a expressão inteira é entre parênteses. Ser capaz de criar uma propriedade calculada é uma das principais razões pelas quais você pode querer criar objetos personalizados.
O comando final Add-Member funciona exatamente como o terceiro, exceto que ele recupera dados da propriedade FreeSpace.
O comando final no bloco de scripts foreach adiciona o objeto atual $systemInfo ao array $SystemInfo. Note que o operador += é usado para garantir que o novo objeto $system seja adicionado a cada iteração do loop, sem que nada seja sobrescrito.
Após executar o código na Listing 4, você pode chamar a variável para ver seu conteúdo. A Figura 7 mostra uma lista parcial dos dados agora armazenados no array $SystemInfo.
Specificamente, mostra os dados para os primeiros sete objetos do array, o que corresponde às primeiras sete linhas de dados no arquivo de texto original. Cada agrupamento representa um dos objetos adicionados ao array $SystemInfo. Você pode verificar que você criou um array de objetos usando o método GetType para obter o tipo da variável:
$SystemInfo.GetType()
Se este comando retornar um BaseType do System.Array, a variável $SystemInfo é de fato um array de objetos capaz de manter objetos personalizados. Você pode então usar essa variável para manipular os dados da forma que você achar conveniente. Por exemplo, você pode pipear a variável para um comando Sort-Object para ordenar os dados em ordem decrescente, baseado nos valores FreeSpace:
$SystemInfo | Sort FreeSpace -Descending
Neste caso, o comando usa o alias Sort para referenciar o cmdlet Sort-Object e inclui a propriedade FreeSpace e o parâmetro -Descending. Como você pode ver na Figura 8, os objetos agora são listados de acordo com os valores do FreeSpace, com a maior quantidade de espaço livre listada primeiro. Mais uma vez, esta é apenas uma lista parcial.
Vocês também podem ordenar os dados com base em múltiplas colunas. Por exemplo, você pode ordenar os dados primeiro pela propriedade Computador, depois pela propriedade Espaço Livre, em ordem decrescente:
$SystemInfo | Sort Computer, FreeSpace -Descending
Como você esperaria, os resultados agora são muito diferentes, como mostra a Figura 9.
Uma das consequências de ordenar as colunas desta forma é que os valores do Computador, assim como os valores do Espaço Livre, são ordenados em ordem decrescente. O cmdlet de Ordenação-Objeto não permite ordenar facilmente uma coluna em ordem ascendente e outra em ordem descendente. Se você especificar o parâmetro -Descendente, todos os dados são ordenados nessa ordem. No entanto, você pode contornar essa limitação criando expressões para cada propriedade que especificam como ordenar esses valores. Por exemplo, o seguinte comando ordena primeiro pela propriedade Computer em ordem ascendente, depois pela propriedade FreeSpace em ordem descendente:
$SystemInfo | Sort ` @{Expression="Computer"; Descending=$false}, @{Expression="FreeSpace"; Descending=$true}
A primeira expressão Sort-Object define a propriedade Expression para Computer e a propriedade Descendente para $false. A segunda expressão define a propriedade Expression para FreeSpace e a propriedade Descending para $true (As variáveis $true e $false são variáveis de sistema embutidas que fornecem os valores true e false Boolean de 1 e 0, respectivamente). Você deve então anexar cada expressão entre parênteses curvos e preceder cada parêntese de abertura com o símbolo at (@). Agora os dados serão ordenados na ordem desejada, como mostrado na Figura 10.
Isso pode parecer um exagero no tópico de ordenação, mas aponta para a flexibilidade de trabalhar com objetos em um array. E você certamente não está limitado ao cmdlet Sort-Object. Por exemplo, o seguinte comando canaliza a variável $SystemInfo para a cmdlet Where-Object:
$SystemInfo | Where DriveSize -gt 250 | Sort FreeSpace -Descending
Neste caso, o comando usa o comando Where alias para referenciar a cmdlet Where-Object. Além disso, ele especifica que o valor do DriveSize deve ser maior que 250 para ser incluído nos resultados. (No PowerShell, -gt é usado para o maior que o operador.) Os resultados que atendem a esses critérios são pipedados para o cmdlet de Ordenação-Objeto para que os dados sejam exibidos na ordem correta.
Você pode até mesmo pipar os dados ordenados para um comando Select-Object, como este:
$SystemInfo | Where DriveSize -gt 250 | Sort FreeSpace -Descending | Select -First 5
Este comando usa o cmdlet de Ordenação-Objeto (referenciado pelo alias Select) para retornar apenas as cinco primeiras linhas do conjunto de resultados. Como você pode ver, uma vez que você adiciona objetos personalizados ao array $SystemInfo, você tem uma variedade de opções para trabalhar com esses objetos.
Making the Most of Your Custom Objects
Para a maior parte, criar objetos personalizados no PowerShell é um processo bastante simples. Se houver alguma complexidade envolvida, ela geralmente vem das expressões de valor que você define para suas propriedades de notas ou métodos de script. As expressões nestes exemplos são relativamente simples em comparação com os tipos de expressões que você pode criar no PowerShell. Mesmo assim, o que você viu aqui deve fornecer-lhe a base necessária para criar objetos personalizados. Quando usadas eficazmente, elas podem ser um componente poderoso dos seus scripts PowerShell, quer você crie objetos individuais, adicione-os a um array, ou use-os de alguma outra forma. Você pode, por exemplo, criar objetos personalizados dentro do seu perfil PowerShell para que eles estejam disponíveis cada vez que você iniciar uma nova sessão. Como você usa objetos personalizados em seus scripts é com você. Saiba apenas que o objecto personalizado é uma ferramenta eficaz e flexível que pode servir muitas das suas necessidades de script.
Para mais informações sobre como criar objectos personalizados no Windows PowerShell, veja “Criar objectos personalizados no Windows PowerShell” de Bill Stewart.”